chrome-devtools-frontend 1.0.1036501 → 1.0.1038113

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/Errors.d.ts

@@ -57,6 +57,7 @@ export interface PuppeteerErrors {
  *
  * @example
  * An example of handling a timeout error:
+ *
  * ```ts
  * try {
  *   await page.waitForSelector('.foo');

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/Errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../../../src/common/Errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED;;;;;;;;;GASG;AACH,qBAAa,YAAa,SAAQ,WAAW;CAAG;AAEhD;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,WAAW;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,SAAM;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,aAAa,EAAE,OAAO,aAAa,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,MAAM,EAAE,eAGnB,CAAC"}
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../../../src/common/Errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,CAAC,EAAE,MAAM;CAK7B;AAED;;;;;;;;;GASG;AACH,qBAAa,YAAa,SAAQ,WAAW;CAAG;AAEhD;;;;GAIG;AACH,qBAAa,aAAc,SAAQ,WAAW;IACrC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,eAAe,SAAM;CAC7B;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,YAAY,EAAE,OAAO,YAAY,CAAC;IAClC,aAAa,EAAE,OAAO,aAAa,CAAC;CACrC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,MAAM,EAAE,eAGnB,CAAC"}

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/Errors.js

@@ -56,6 +56,7 @@ export class ProtocolError extends CustomError {
  *
  * @example
  * An example of handling a timeout error:
+ *
  * ```ts
  * try {
  *   await page.waitForSelector('.foo');

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/Errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"Errors.js","sourceRoot":"","sources":["../../../../src/common/Errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QAClC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,YAAa,SAAQ,WAAW;CAAG;AAEhD;;;;GAIG;AACH,MAAM,OAAO,aAAc,SAAQ,WAAW;IAA9C;;QAES,oBAAe,GAAG,EAAE,CAAC;IAC9B,CAAC;CAAA;AAUD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAoB,MAAM,CAAC,MAAM,CAAC;IACnD,YAAY;IACZ,aAAa;CACd,CAAC,CAAC"}
+{"version":3,"file":"Errors.js","sourceRoot":"","sources":["../../../../src/common/Errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;GAEG;AACH,MAAM,OAAO,WAAY,SAAQ,KAAK;IACpC,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;QAClC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IAClD,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,YAAa,SAAQ,WAAW;CAAG;AAEhD;;;;GAIG;AACH,MAAM,OAAO,aAAc,SAAQ,WAAW;IAA9C;;QAES,oBAAe,GAAG,EAAE,CAAC;IAC9B,CAAC;CAAA;AAUD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,CAAC,MAAM,MAAM,GAAoB,MAAM,CAAC,MAAM,CAAC;IACnD,YAAY;IACZ,aAAa;CACd,CAAC,CAAC"}

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/EventEmitter.d.ts

@@ -38,14 +38,14 @@ export declare class EventEmitter implements CommonEventEmitter {
     /**
      * Bind an event listener to fire when an event occurs.
      * @param event - the event type you'd like to listen to. Can be a string or symbol.
-     * @param handler  - the function to be called when the event occurs.
+     * @param handler - the function to be called when the event occurs.
      * @returns `this` to enable you to chain method calls.
      */
     on(event: EventType, handler: Handler): EventEmitter;
     /**
      * Remove an event listener from firing.
      * @param event - the event type you'd like to stop listening to.
-     * @param handler  - the function that should be removed.
+     * @param handler - the function that should be removed.
      * @returns `this` to enable you to chain method calls.
      */
     off(event: EventType, handler: Handler): EventEmitter;

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/EventEmitter.js

@@ -22,7 +22,7 @@ export class EventEmitter {
     /**
      * Bind an event listener to fire when an event occurs.
      * @param event - the event type you'd like to listen to. Can be a string or symbol.
-     * @param handler  - the function to be called when the event occurs.
+     * @param handler - the function to be called when the event occurs.
      * @returns `this` to enable you to chain method calls.
      */
     on(event, handler) {
@@ -32,7 +32,7 @@ export class EventEmitter {
     /**
      * Remove an event listener from firing.
      * @param event - the event type you'd like to stop listening to.
-     * @param handler  - the function that should be removed.
+     * @param handler - the function that should be removed.
      * @returns `this` to enable you to chain method calls.
      */
     off(event, handler) {

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/ExecutionContext.d.ts

@@ -15,9 +15,8 @@
  */
 import { Protocol } from 'devtools-protocol';
 import { CDPSession } from './Connection.js';
-import { DOMWorld } from './DOMWorld.js';
-import { ElementHandle } from './ElementHandle.js';
-import { Frame } from './FrameManager.js';
+import { Frame } from './Frame.js';
+import { IsolatedWorld } from './IsolatedWorld.js';
 import { JSHandle } from './JSHandle.js';
 import { EvaluateFunc, HandleFor } from './types.js';
 /**
@@ -25,21 +24,26 @@ import { EvaluateFunc, HandleFor } from './types.js';
  */
 export declare const EVALUATION_SCRIPT_URL = "pptr://__puppeteer_evaluation_script__";
 /**
- * This class represents a context for JavaScript execution. A [Page] might have
- * many execution contexts:
- * - each
- *   {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe |
- *   frame } has "default" execution context that is always created after frame is
- *   attached to DOM. This context is returned by the
- *   {@link Frame.executionContext} method.
- * - {@link https://developer.chrome.com/extensions | Extension}'s content scripts
- *   create additional execution contexts.
+ * @deprecated Do not use directly.
  *
- * Besides pages, execution contexts can be found in
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API |
- * workers }.
+ * Represents a context for JavaScript execution.
  *
- * @public
+ * @example
+ * A {@link Page} can have several execution contexts:
+ *
+ * - Each {@link Frame} of a {@link Page | page} has a "default" execution
+ *   context that is always created after frame is attached to DOM. This context
+ *   is returned by the {@link Frame.executionContext} method.
+ * - Each {@link https://developer.chrome.com/extensions | Chrome extensions}
+ *   creates additional execution contexts to isolate their code.
+ *
+ * @remarks
+ * By definition, each context is isolated from one another, however they are
+ * all able to manipulate non-JavaScript resources (such as DOM).
+ *
+ * @remarks
+ * Besides pages, execution contexts can be found in
+ * {@link WebWorker | workers}.
  */
 export declare class ExecutionContext {
     #private;
@@ -50,7 +54,7 @@ export declare class ExecutionContext {
     /**
      * @internal
      */
-    _world?: DOMWorld;
+    _world?: IsolatedWorld;
     /**
      * @internal
      */
@@ -62,29 +66,21 @@ export declare class ExecutionContext {
     /**
      * @internal
      */
-    constructor(client: CDPSession, contextPayload: Protocol.Runtime.ExecutionContextDescription, world?: DOMWorld);
+    constructor(client: CDPSession, contextPayload: Protocol.Runtime.ExecutionContextDescription, world?: IsolatedWorld);
     /**
-     * @remarks
-     *
-     * Not every execution context is associated with a frame. For
-     * example, workers and extensions have execution contexts that are not
-     * associated with frames.
-     *
      * @returns The frame associated with this execution context.
+     *
+     * @remarks
+     * Not every execution context is associated with a frame. For example,
+     * {@link WebWorker | workers} have execution contexts that are not associated
+     * with frames.
      */
     frame(): Frame | null;
     /**
-     * @remarks
-     * If the function passed to the `executionContext.evaluate` returns a
-     * Promise, then `executionContext.evaluate` would wait for the promise to
-     * resolve and return its value. If the function passed to the
-     * `executionContext.evaluate` returns a non-serializable value, then
-     * `executionContext.evaluate` resolves to `undefined`. DevTools Protocol also
-     * supports transferring some additional values that are not serializable by
-     * `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
-     *
+     * Evaluates the given function.
      *
      * @example
+     *
      * ```ts
      * const executionContext = await page.mainFrame().executionContext();
      * const result = await executionContext.evaluate(() => Promise.resolve(8 * 7))* ;
@@ -92,82 +88,94 @@ export declare class ExecutionContext {
      * ```
      *
      * @example
-     * A string can also be passed in instead of a function.
+     * A string can also be passed in instead of a function:
      *
      * ```ts
      * console.log(await executionContext.evaluate('1 + 2')); // prints "3"
      * ```
      *
      * @example
-     * {@link JSHandle} instances can be passed as arguments to the
-     * `executionContext.* evaluate`:
+     * Handles can also be passed as `args`. They resolve to their referenced object:
+     *
      * ```ts
      * const oneHandle = await executionContext.evaluateHandle(() => 1);
      * const twoHandle = await executionContext.evaluateHandle(() => 2);
      * const result = await executionContext.evaluate(
-     *    (a, b) => a + b, oneHandle, * twoHandle
+     *   (a, b) => a + b,
+     *   oneHandle,
+     *   twoHandle
      * );
      * await oneHandle.dispose();
      * await twoHandle.dispose();
      * console.log(result); // prints '3'.
      * ```
-     * @param pageFunction - a function to be evaluated in the `executionContext`
-     * @param args - argument to pass to the page function
      *
-     * @returns A promise that resolves to the return value of the given function.
+     * @param pageFunction - The function to evaluate.
+     * @param args - Additional arguments to pass into the function.
+     * @returns The result of evaluating the function. If the result is an object,
+     * a vanilla object containing the serializable properties of the result is
+     * returned.
      */
     evaluate<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<Awaited<ReturnType<Func>>>;
     /**
-     * @remarks
-     * The only difference between `executionContext.evaluate` and
-     * `executionContext.evaluateHandle` is that `executionContext.evaluateHandle`
-     * returns an in-page object (a {@link JSHandle}).
-     * If the function passed to the `executionContext.evaluateHandle` returns a
-     * Promise, then `executionContext.evaluateHandle` would wait for the
-     * promise to resolve and return its value.
+     * Evaluates the given function.
+     *
+     * Unlike {@link ExecutionContext.evaluate | evaluate}, this method returns a
+     * handle to the result of the function.
+     *
+     * This method may be better suited if the object cannot be serialized (e.g.
+     * `Map`) and requires further manipulation.
      *
      * @example
+     *
      * ```ts
      * const context = await page.mainFrame().executionContext();
-     * const aHandle = await context.evaluateHandle(() => Promise.resolve(self));
-     * aHandle; // Handle for the global object.
+     * const handle: JSHandle<typeof globalThis> = await context.evaluateHandle(
+     *   () => Promise.resolve(self)
+     * );
      * ```
      *
      * @example
      * A string can also be passed in instead of a function.
      *
      * ```ts
-     * // Handle for the '3' * object.
-     * const aHandle = await context.evaluateHandle('1 + 2');
+     * const handle: JSHandle<number> = await context.evaluateHandle('1 + 2');
      * ```
      *
      * @example
-     * JSHandle instances can be passed as arguments
-     * to the `executionContext.* evaluateHandle`:
+     * Handles can also be passed as `args`. They resolve to their referenced object:
      *
      * ```ts
-     * const aHandle = await context.evaluateHandle(() => document.body);
-     * const resultHandle = await context.evaluateHandle(body => body.innerHTML, * aHandle);
-     * console.log(await resultHandle.jsonValue()); // prints body's innerHTML
-     * await aHandle.dispose();
-     * await resultHandle.dispose();
+     * const bodyHandle: ElementHandle<HTMLBodyElement> =
+     *   await context.evaluateHandle(() => {
+     *     return document.body;
+     *   });
+     * const stringHandle: JSHandle<string> = await context.evaluateHandle(
+     *   body => body.innerHTML,
+     *   body
+     * );
+     * console.log(await stringHandle.jsonValue()); // prints body's innerHTML
+     * // Always dispose your garbage! :)
+     * await bodyHandle.dispose();
+     * await stringHandle.dispose();
      * ```
      *
-     * @param pageFunction - a function to be evaluated in the `executionContext`
-     * @param args - argument to pass to the page function
-     *
-     * @returns A promise that resolves to the return value of the given function
-     * as an in-page object (a {@link JSHandle}).
+     * @param pageFunction - The function to evaluate.
+     * @param args - Additional arguments to pass into the function.
+     * @returns A {@link JSHandle | handle} to the result of evaluating the
+     * function. If the result is a `Node`, then this will return an
+     * {@link ElementHandle | element handle}.
      */
     evaluateHandle<Params extends unknown[], Func extends EvaluateFunc<Params> = EvaluateFunc<Params>>(pageFunction: Func | string, ...args: Params): Promise<HandleFor<Awaited<ReturnType<Func>>>>;
     /**
-     * This method iterates the JavaScript heap and finds all the objects with the
+     * Iterates through the JavaScript heap and finds all the objects with the
      * given prototype.
-     * @remarks
+     *
      * @example
+     *
      * ```ts
      * // Create a Map object
-     * await page.evaluate(() => window.map = new Map());
+     * await page.evaluate(() => (window.map = new Map()));
      * // Get a handle to the Map object prototype
      * const mapPrototype = await page.evaluateHandle(() => Map.prototype);
      * // Query all map instances into an array
@@ -179,17 +187,8 @@ export declare class ExecutionContext {
      * ```
      *
      * @param prototypeHandle - a handle to the object prototype
-     *
      * @returns A handle to an array of objects with the given prototype.
      */
     queryObjects<Prototype>(prototypeHandle: JSHandle<Prototype>): Promise<HandleFor<Prototype[]>>;
-    /**
-     * @internal
-     */
-    _adoptBackendNodeId(backendNodeId?: Protocol.DOM.BackendNodeId): Promise<ElementHandle<Node>>;
-    /**
-     * @internal
-     */
-    _adoptElementHandle<T extends ElementHandle<Node>>(elementHandle: T): Promise<T>;
 }
 //# sourceMappingURL=ExecutionContext.d.ts.map

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/ExecutionContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ExecutionContext.d.ts","sourceRoot":"","sources":["../../../../src/common/ExecutionContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAC,KAAK,EAAC,MAAM,mBAAmB,CAAC;AACxC,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,YAAY,EAAE,SAAS,EAAC,MAAM,YAAY,CAAC;AAQnD;;GAEG;AACH,eAAO,MAAM,qBAAqB,2CAA2C,CAAC;AAG9E;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAgB;;IAC3B;;OAEG;IACH,OAAO,EAAE,UAAU,CAAC;IACpB;;OAEG;IACH,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;gBAED,MAAM,EAAE,UAAU,EAClB,cAAc,EAAE,QAAQ,CAAC,OAAO,CAAC,2BAA2B,EAC5D,KAAK,CAAC,EAAE,QAAQ;IAQlB;;;;;;;;OAQG;IACH,KAAK,IAAI,KAAK,GAAG,IAAI;IAIrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACG,QAAQ,CACZ,MAAM,SAAS,OAAO,EAAE,EACxB,IAAI,SAAS,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,EAExD,YAAY,EAAE,IAAI,GAAG,MAAM,EAC3B,GAAG,IAAI,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;IAIrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACG,cAAc,CAClB,MAAM,SAAS,OAAO,EAAE,EACxB,IAAI,SAAS,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,EAExD,YAAY,EAAE,IAAI,GAAG,MAAM,EAC3B,GAAG,IAAI,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAgLhD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,YAAY,CAAC,SAAS,EAC1B,eAAe,EAAE,QAAQ,CAAC,SAAS,CAAC,GACnC,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC;IAYlC;;OAEG;IACG,mBAAmB,CACvB,aAAa,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,aAAa,GACzC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAQ/B;;OAEG;IACG,mBAAmB,CAAC,CAAC,SAAS,aAAa,CAAC,IAAI,CAAC,EACrD,aAAa,EAAE,CAAC,GACf,OAAO,CAAC,CAAC,CAAC;CAWd"}
+{"version":3,"file":"ExecutionContext.d.ts","sourceRoot":"","sources":["../../../../src/common/ExecutionContext.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,QAAQ,EAAC,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAC,UAAU,EAAC,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACjC,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAC,QAAQ,EAAC,MAAM,eAAe,CAAC;AACvC,OAAO,EAAC,YAAY,EAAE,SAAS,EAAC,MAAM,YAAY,CAAC;AAQnD;;GAEG;AACH,eAAO,MAAM,qBAAqB,2CAA2C,CAAC;AAG9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,gBAAgB;;IAC3B;;OAEG;IACH,OAAO,EAAE,UAAU,CAAC;IACpB;;OAEG;IACH,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;gBAED,MAAM,EAAE,UAAU,EAClB,cAAc,EAAE,QAAQ,CAAC,OAAO,CAAC,2BAA2B,EAC5D,KAAK,CAAC,EAAE,aAAa;IAQvB;;;;;;;OAOG;IACH,KAAK,IAAI,KAAK,GAAG,IAAI;IAIrB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuCG;IACG,QAAQ,CACZ,MAAM,SAAS,OAAO,EAAE,EACxB,IAAI,SAAS,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,EAExD,YAAY,EAAE,IAAI,GAAG,MAAM,EAC3B,GAAG,IAAI,EAAE,MAAM,GACd,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC;IAIrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgDG;IACG,cAAc,CAClB,MAAM,SAAS,OAAO,EAAE,EACxB,IAAI,SAAS,YAAY,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,MAAM,CAAC,EAExD,YAAY,EAAE,IAAI,GAAG,MAAM,EAC3B,GAAG,IAAI,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IA2KhD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,YAAY,CAAC,SAAS,EAC1B,eAAe,EAAE,QAAQ,CAAC,SAAS,CAAC,GACnC,OAAO,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC,CAAC;CAYnC"}

package/front_end/third_party/puppeteer/package/lib/esm/puppeteer/common/ExecutionContext.js

@@ -19,30 +19,35 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _ExecutionContext_instances, _ExecutionContext_evaluate;
-import { assert } from './assert.js';
+import { assert } from '../util/assert.js';
 import { JSHandle } from './JSHandle.js';
-import { getExceptionMessage, isString, valueFromRemoteObject, createJSHandle, } from './util.js';
+import { createJSHandle, getExceptionMessage, isString, valueFromRemoteObject, } from './util.js';
 /**
  * @public
  */
 export const EVALUATION_SCRIPT_URL = 'pptr://__puppeteer_evaluation_script__';
 const SOURCE_URL_REGEX = /^[\040\t]*\/\/[@#] sourceURL=\s*(\S*?)\s*$/m;
 /**
- * This class represents a context for JavaScript execution. A [Page] might have
- * many execution contexts:
- * - each
- *   {@link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe |
- *   frame } has "default" execution context that is always created after frame is
- *   attached to DOM. This context is returned by the
- *   {@link Frame.executionContext} method.
- * - {@link https://developer.chrome.com/extensions | Extension}'s content scripts
- *   create additional execution contexts.
+ * @deprecated Do not use directly.
  *
- * Besides pages, execution contexts can be found in
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API |
- * workers }.
+ * Represents a context for JavaScript execution.
  *
- * @public
+ * @example
+ * A {@link Page} can have several execution contexts:
+ *
+ * - Each {@link Frame} of a {@link Page | page} has a "default" execution
+ *   context that is always created after frame is attached to DOM. This context
+ *   is returned by the {@link Frame.executionContext} method.
+ * - Each {@link https://developer.chrome.com/extensions | Chrome extensions}
+ *   creates additional execution contexts to isolate their code.
+ *
+ * @remarks
+ * By definition, each context is isolated from one another, however they are
+ * all able to manipulate non-JavaScript resources (such as DOM).
+ *
+ * @remarks
+ * Besides pages, execution contexts can be found in
+ * {@link WebWorker | workers}.
  */
 export class ExecutionContext {
     /**
@@ -56,29 +61,21 @@ export class ExecutionContext {
         this._contextName = contextPayload.name;
     }
     /**
-     * @remarks
-     *
-     * Not every execution context is associated with a frame. For
-     * example, workers and extensions have execution contexts that are not
-     * associated with frames.
-     *
      * @returns The frame associated with this execution context.
+     *
+     * @remarks
+     * Not every execution context is associated with a frame. For example,
+     * {@link WebWorker | workers} have execution contexts that are not associated
+     * with frames.
      */
     frame() {
         return this._world ? this._world.frame() : null;
     }
     /**
-     * @remarks
-     * If the function passed to the `executionContext.evaluate` returns a
-     * Promise, then `executionContext.evaluate` would wait for the promise to
-     * resolve and return its value. If the function passed to the
-     * `executionContext.evaluate` returns a non-serializable value, then
-     * `executionContext.evaluate` resolves to `undefined`. DevTools Protocol also
-     * supports transferring some additional values that are not serializable by
-     * `JSON`: `-0`, `NaN`, `Infinity`, `-Infinity`, and bigint literals.
-     *
+     * Evaluates the given function.
      *
      * @example
+     *
      * ```ts
      * const executionContext = await page.mainFrame().executionContext();
      * const result = await executionContext.evaluate(() => Promise.resolve(8 * 7))* ;
@@ -86,86 +83,98 @@ export class ExecutionContext {
      * ```
      *
      * @example
-     * A string can also be passed in instead of a function.
+     * A string can also be passed in instead of a function:
      *
      * ```ts
      * console.log(await executionContext.evaluate('1 + 2')); // prints "3"
      * ```
      *
      * @example
-     * {@link JSHandle} instances can be passed as arguments to the
-     * `executionContext.* evaluate`:
+     * Handles can also be passed as `args`. They resolve to their referenced object:
+     *
      * ```ts
      * const oneHandle = await executionContext.evaluateHandle(() => 1);
      * const twoHandle = await executionContext.evaluateHandle(() => 2);
      * const result = await executionContext.evaluate(
-     *    (a, b) => a + b, oneHandle, * twoHandle
+     *   (a, b) => a + b,
+     *   oneHandle,
+     *   twoHandle
      * );
      * await oneHandle.dispose();
      * await twoHandle.dispose();
      * console.log(result); // prints '3'.
      * ```
-     * @param pageFunction - a function to be evaluated in the `executionContext`
-     * @param args - argument to pass to the page function
      *
-     * @returns A promise that resolves to the return value of the given function.
+     * @param pageFunction - The function to evaluate.
+     * @param args - Additional arguments to pass into the function.
+     * @returns The result of evaluating the function. If the result is an object,
+     * a vanilla object containing the serializable properties of the result is
+     * returned.
      */
     async evaluate(pageFunction, ...args) {
         return await __classPrivateFieldGet(this, _ExecutionContext_instances, "m", _ExecutionContext_evaluate).call(this, true, pageFunction, ...args);
     }
     /**
-     * @remarks
-     * The only difference between `executionContext.evaluate` and
-     * `executionContext.evaluateHandle` is that `executionContext.evaluateHandle`
-     * returns an in-page object (a {@link JSHandle}).
-     * If the function passed to the `executionContext.evaluateHandle` returns a
-     * Promise, then `executionContext.evaluateHandle` would wait for the
-     * promise to resolve and return its value.
+     * Evaluates the given function.
+     *
+     * Unlike {@link ExecutionContext.evaluate | evaluate}, this method returns a
+     * handle to the result of the function.
+     *
+     * This method may be better suited if the object cannot be serialized (e.g.
+     * `Map`) and requires further manipulation.
      *
      * @example
+     *
      * ```ts
      * const context = await page.mainFrame().executionContext();
-     * const aHandle = await context.evaluateHandle(() => Promise.resolve(self));
-     * aHandle; // Handle for the global object.
+     * const handle: JSHandle<typeof globalThis> = await context.evaluateHandle(
+     *   () => Promise.resolve(self)
+     * );
      * ```
      *
      * @example
      * A string can also be passed in instead of a function.
      *
      * ```ts
-     * // Handle for the '3' * object.
-     * const aHandle = await context.evaluateHandle('1 + 2');
+     * const handle: JSHandle<number> = await context.evaluateHandle('1 + 2');
      * ```
      *
      * @example
-     * JSHandle instances can be passed as arguments
-     * to the `executionContext.* evaluateHandle`:
+     * Handles can also be passed as `args`. They resolve to their referenced object:
      *
      * ```ts
-     * const aHandle = await context.evaluateHandle(() => document.body);
-     * const resultHandle = await context.evaluateHandle(body => body.innerHTML, * aHandle);
-     * console.log(await resultHandle.jsonValue()); // prints body's innerHTML
-     * await aHandle.dispose();
-     * await resultHandle.dispose();
+     * const bodyHandle: ElementHandle<HTMLBodyElement> =
+     *   await context.evaluateHandle(() => {
+     *     return document.body;
+     *   });
+     * const stringHandle: JSHandle<string> = await context.evaluateHandle(
+     *   body => body.innerHTML,
+     *   body
+     * );
+     * console.log(await stringHandle.jsonValue()); // prints body's innerHTML
+     * // Always dispose your garbage! :)
+     * await bodyHandle.dispose();
+     * await stringHandle.dispose();
      * ```
      *
-     * @param pageFunction - a function to be evaluated in the `executionContext`
-     * @param args - argument to pass to the page function
-     *
-     * @returns A promise that resolves to the return value of the given function
-     * as an in-page object (a {@link JSHandle}).
+     * @param pageFunction - The function to evaluate.
+     * @param args - Additional arguments to pass into the function.
+     * @returns A {@link JSHandle | handle} to the result of evaluating the
+     * function. If the result is a `Node`, then this will return an
+     * {@link ElementHandle | element handle}.
      */
     async evaluateHandle(pageFunction, ...args) {
         return __classPrivateFieldGet(this, _ExecutionContext_instances, "m", _ExecutionContext_evaluate).call(this, false, pageFunction, ...args);
     }
     /**
-     * This method iterates the JavaScript heap and finds all the objects with the
+     * Iterates through the JavaScript heap and finds all the objects with the
      * given prototype.
-     * @remarks
+     *
      * @example
+     *
      * ```ts
      * // Create a Map object
-     * await page.evaluate(() => window.map = new Map());
+     * await page.evaluate(() => (window.map = new Map()));
      * // Get a handle to the Map object prototype
      * const mapPrototype = await page.evaluateHandle(() => Map.prototype);
      * // Query all map instances into an array
@@ -177,38 +186,17 @@ export class ExecutionContext {
      * ```
      *
      * @param prototypeHandle - a handle to the object prototype
-     *
      * @returns A handle to an array of objects with the given prototype.
      */
     async queryObjects(prototypeHandle) {
-        assert(!prototypeHandle._disposed, 'Prototype JSHandle is disposed!');
-        assert(prototypeHandle._remoteObject.objectId, 'Prototype JSHandle must not be referencing primitive value');
+        assert(!prototypeHandle.disposed, 'Prototype JSHandle is disposed!');
+        const remoteObject = prototypeHandle.remoteObject();
+        assert(remoteObject.objectId, 'Prototype JSHandle must not be referencing primitive value');
         const response = await this._client.send('Runtime.queryObjects', {
-            prototypeObjectId: prototypeHandle._remoteObject.objectId,
+            prototypeObjectId: remoteObject.objectId,
         });
         return createJSHandle(this, response.objects);
     }
-    /**
-     * @internal
-     */
-    async _adoptBackendNodeId(backendNodeId) {
-        const { object } = await this._client.send('DOM.resolveNode', {
-            backendNodeId: backendNodeId,
-            executionContextId: this._contextId,
-        });
-        return createJSHandle(this, object);
-    }
-    /**
-     * @internal
-     */
-    async _adoptElementHandle(elementHandle) {
-        assert(elementHandle.executionContext() !== this, 'Cannot adopt handle that already belongs to this execution context');
-        assert(this._world, 'Cannot adopt handle without DOMWorld');
-        const nodeInfo = await this._client.send('DOM.describeNode', {
-            objectId: elementHandle._remoteObject.objectId,
-        });
-        return (await this._adoptBackendNodeId(nodeInfo.node.backendNodeId));
-    }
 }
 _ExecutionContext_instances = new WeakSet(), _ExecutionContext_evaluate = async function _ExecutionContext_evaluate(returnByValue, pageFunction, ...args) {
     const suffix = `//# sourceURL=${EVALUATION_SCRIPT_URL}`;
@@ -234,9 +222,6 @@ _ExecutionContext_instances = new WeakSet(), _ExecutionContext_evaluate = async
             ? valueFromRemoteObject(remoteObject)
             : createJSHandle(this, remoteObject);
     }
-    if (typeof pageFunction !== 'function') {
-        throw new Error(`Expected to get |string| or |function| as the first argument, but got "${pageFunction}" instead.`);
-    }
     let functionText = pageFunction.toString();
     try {
         new Function('(' + functionText + ')');
@@ -303,21 +288,21 @@ _ExecutionContext_instances = new WeakSet(), _ExecutionContext_evaluate = async
         }
         const objectHandle = arg && arg instanceof JSHandle ? arg : null;
         if (objectHandle) {
-            if (objectHandle._context !== this) {
+            if (objectHandle.executionContext() !== this) {
                 throw new Error('JSHandles can be evaluated only in the context they were created!');
             }
-            if (objectHandle._disposed) {
+            if (objectHandle.disposed) {
                 throw new Error('JSHandle is disposed!');
             }
-            if (objectHandle._remoteObject.unserializableValue) {
+            if (objectHandle.remoteObject().unserializableValue) {
                 return {
-                    unserializableValue: objectHandle._remoteObject.unserializableValue,
+                    unserializableValue: objectHandle.remoteObject().unserializableValue,
                 };
             }
-            if (!objectHandle._remoteObject.objectId) {
-                return { value: objectHandle._remoteObject.value };
+            if (!objectHandle.remoteObject().objectId) {
+                return { value: objectHandle.remoteObject().value };
             }
-            return { objectId: objectHandle._remoteObject.objectId };
+            return { objectId: objectHandle.remoteObject().objectId };
         }
         return { value: arg };
     }