123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375
/// <reference types="./ExecutionContext.d.ts" />/** * Copyright 2017 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 __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 _ExecutionContext_instances, _ExecutionContext_evaluate;import { assert } from "../util/assert.js";import { JSHandle } from "./JSHandle.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;/** * @deprecated Do not use directly. * * Represents a context for JavaScript execution. * * @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 {  /**   * @internal   */  constructor(client, contextPayload, world) {    _ExecutionContext_instances.add(this);    this._client = client;    this._world = world;    this._contextId = contextPayload.id;    this._contextName = contextPayload.name;  }  /**   * @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;  }  /**   * Evaluates the given function.   *   * @example   *   * ```ts   * const executionContext = await page.mainFrame().executionContext();   * const result = await executionContext.evaluate(() => Promise.resolve(8 * 7))* ;   * console.log(result); // prints "56"   * ```   *   * @example   * A string can also be passed in instead of a function:   *   * ```ts   * console.log(await executionContext.evaluate('1 + 2')); // prints "3"   * ```   *   * @example   * 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   * );   * await oneHandle.dispose();   * await twoHandle.dispose();   * console.log(result); // prints '3'.   * ```   *   * @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);  }  /**   * 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 handle: JSHandle<typeof globalThis> = await context.evaluateHandle(   *   () => Promise.resolve(self)   * );   * ```   *   * @example   * A string can also be passed in instead of a function.   *   * ```ts   * const handle: JSHandle<number> = await context.evaluateHandle('1 + 2');   * ```   *   * @example   * Handles can also be passed as `args`. They resolve to their referenced object:   *   * ```ts   * 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 - 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);  }  /**   * Iterates through the JavaScript heap and finds all the objects with the   * given prototype.   *   * @example   *   * ```ts   * // Create a Map object   * 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   * const mapInstances = await page.queryObjects(mapPrototype);   * // Count amount of map objects in heap   * const count = await page.evaluate(maps => maps.length, mapInstances);   * await mapInstances.dispose();   * await mapPrototype.dispose();   * ```   *   * @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!");    const remoteObject = prototypeHandle.remoteObject();    assert(      remoteObject.objectId,      "Prototype JSHandle must not be referencing primitive value",    );    const response = await this._client.send("Runtime.queryObjects", {      prototypeObjectId: remoteObject.objectId,    });    return createJSHandle(this, response.objects);  }}_ExecutionContext_instances = new WeakSet(),  _ExecutionContext_evaluate = async function _ExecutionContext_evaluate(    returnByValue,    pageFunction,    ...args  ) {    const suffix = `//# sourceURL=${EVALUATION_SCRIPT_URL}`;    if (isString(pageFunction)) {      const contextId = this._contextId;      const expression = pageFunction;      const expressionWithSourceUrl = SOURCE_URL_REGEX.test(expression)        ? expression        : expression + "\n" + suffix;      const { exceptionDetails, result: remoteObject } = await this._client        .send("Runtime.evaluate", {          expression: expressionWithSourceUrl,          contextId,          returnByValue,          awaitPromise: true,          userGesture: true,        })        .catch(rewriteError);      if (exceptionDetails) {        throw new Error(          "Evaluation failed: " + getExceptionMessage(exceptionDetails),        );      }      return returnByValue        ? valueFromRemoteObject(remoteObject)        : createJSHandle(this, remoteObject);    }    let functionText = pageFunction.toString();    try {      new Function("(" + functionText + ")");    } catch (error) {      // This means we might have a function shorthand. Try another      // time prefixing 'function '.      if (functionText.startsWith("async ")) {        functionText = "async function " +          functionText.substring("async ".length);      } else {        functionText = "function " + functionText;      }      try {        new Function("(" + functionText + ")");      } catch (error) {        // We tried hard to serialize, but there's a weird beast here.        throw new Error("Passed function is not well-serializable!");      }    }    let callFunctionOnPromise;    try {      callFunctionOnPromise = this._client.send("Runtime.callFunctionOn", {        functionDeclaration: functionText + "\n" + suffix + "\n",        executionContextId: this._contextId,        arguments: args.map(convertArgument.bind(this)),        returnByValue,        awaitPromise: true,        userGesture: true,      });    } catch (error) {      if (        error instanceof TypeError &&        error.message.startsWith("Converting circular structure to JSON")      ) {        error.message += " Recursive objects are not allowed.";      }      throw error;    }    const { exceptionDetails, result: remoteObject } =      await callFunctionOnPromise.catch(rewriteError);    if (exceptionDetails) {      throw new Error(        "Evaluation failed: " + getExceptionMessage(exceptionDetails),      );    }    return returnByValue      ? valueFromRemoteObject(remoteObject)      : createJSHandle(this, remoteObject);    function convertArgument(arg) {      if (typeof arg === "bigint") {        // eslint-disable-line valid-typeof        return { unserializableValue: `${arg.toString()}n` };      }      if (Object.is(arg, -0)) {        return { unserializableValue: "-0" };      }      if (Object.is(arg, Infinity)) {        return { unserializableValue: "Infinity" };      }      if (Object.is(arg, -Infinity)) {        return { unserializableValue: "-Infinity" };      }      if (Object.is(arg, NaN)) {        return { unserializableValue: "NaN" };      }      const objectHandle = arg && arg instanceof JSHandle ? arg : null;      if (objectHandle) {        if (objectHandle.executionContext() !== this) {          throw new Error(            "JSHandles can be evaluated only in the context they were created!",          );        }        if (objectHandle.disposed) {          throw new Error("JSHandle is disposed!");        }        if (objectHandle.remoteObject().unserializableValue) {          return {            unserializableValue:              objectHandle.remoteObject().unserializableValue,          };        }        if (!objectHandle.remoteObject().objectId) {          return { value: objectHandle.remoteObject().value };        }        return { objectId: objectHandle.remoteObject().objectId };      }      return { value: arg };    }    function rewriteError(error) {      if (error.message.includes("Object reference chain is too long")) {        return { result: { type: "undefined" } };      }      if (error.message.includes("Object couldn't be returned by value")) {        return { result: { type: "undefined" } };      }      if (        error.message.endsWith("Cannot find context with specified id") ||        error.message.endsWith("Inspected target navigated or closed")      ) {        throw new Error(          "Execution context was destroyed, most likely because of a navigation.",        );      }      throw error;    }  };//# sourceMappingURL=ExecutionContext.js.map