apify 3.0.0-alpha.2 → 3.0.0-alpha.20

package/actor.js

@@ -0,0 +1,1221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXIT_CODES = exports.Actor = void 0;
+const tslib_1 = require("tslib");
+const ow_1 = tslib_1.__importDefault(require("ow"));
+const consts_1 = require("@apify/consts");
+const log_1 = tslib_1.__importDefault(require("@apify/log"));
+const apify_client_1 = require("apify-client");
+const core_1 = require("@crawlee/core");
+const utils_1 = require("@crawlee/utils");
+const utils_2 = require("./utils");
+const platform_event_manager_1 = require("./platform_event_manager");
+const proxy_configuration_1 = require("./proxy_configuration");
+/**
+ * `Apify` class serves as an alternative approach to the static helpers exported from the package. It allows to pass configuration
+ * that will be used on the instance methods. Environment variables will have precedence over this configuration.
+ * See {@link Configuration} for details about what can be configured and what are the default values.
+ */
+class Actor {
+    constructor(options = {}) {
+        /**
+         * Configuration of this SDK instance (provided to its constructor). See {@link Configuration} for details.
+         * @internal
+         */
+        Object.defineProperty(this, "config", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Default {@link ApifyClient} instance.
+         * @internal
+         */
+        Object.defineProperty(this, "apifyClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * Default {@link EventManager} instance.
+         * @internal
+         */
+        Object.defineProperty(this, "eventManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "storageManagers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        // use default configuration object if nothing overridden (it fallbacks to env vars)
+        this.config = Object.keys(options).length === 0 ? core_1.Configuration.getGlobalConfig() : new core_1.Configuration(options);
+        this.apifyClient = this.newClient();
+        this.eventManager = new platform_event_manager_1.PlatformEventManager(this.config);
+    }
+    /**
+     * Runs the main user function that performs the job of the actor
+     * and terminates the process when the user function finishes.
+     *
+     * **The `Actor.main()` function is optional** and is provided merely for your convenience.
+     * It is mainly useful when you're running your code as an actor on the [Apify platform](https://apify.com/actors).
+     * However, if you want to use Apify SDK tools directly inside your existing projects, e.g.
+     * running in an [Express](https://expressjs.com/) server, on
+     * [Google Cloud functions](https://cloud.google.com/functions)
+     * or [AWS Lambda](https://aws.amazon.com/lambda/), it's better to avoid
+     * it since the function terminates the main process when it finishes!
+     *
+     * The `Actor.main()` function performs the following actions:
+     *
+     * - When running on the Apify platform (i.e. `APIFY_IS_AT_HOME` environment variable is set),
+     *   it sets up a connection to listen for platform events.
+     *   For example, to get a notification about an imminent migration to another server.
+     *   See {@link Actor.events} for details.
+     * - It checks that either `APIFY_TOKEN` or `APIFY_LOCAL_STORAGE_DIR` environment variable
+     *   is defined. If not, the functions sets `APIFY_LOCAL_STORAGE_DIR` to `./apify_storage`
+     *   inside the current working directory. This is to simplify running code examples.
+     * - It invokes the user function passed as the `userFunc` parameter.
+     * - If the user function returned a promise, waits for it to resolve.
+     * - If the user function throws an exception or some other error is encountered,
+     *   prints error details to console so that they are stored to the log.
+     * - Exits the Node.js process, with zero exit code on success and non-zero on errors.
+     *
+     * The user function can be synchronous:
+     *
+     * ```javascript
+     * Actor.main(() => {
+     *   // My synchronous function that returns immediately
+     *   console.log('Hello world from actor!');
+     * });
+     * ```
+     *
+     * If the user function returns a promise, it is considered asynchronous:
+     * ```javascript
+     * const { gotScraping } = require('got-scraping');
+     *
+     * Actor.main(() => {
+     *   // My asynchronous function that returns a promise
+     *   return gotScraping('http://www.example.com').then((html) => {
+     *     console.log(html);
+     *   });
+     * });
+     * ```
+     *
+     * To simplify your code, you can take advantage of the `async`/`await` keywords:
+     *
+     * ```javascript
+     * const { gotScraping } = require('got-scraping');
+     *
+     * Actor.main(async () => {
+     *   // My asynchronous function
+     *   const html = await request('http://www.example.com');
+     *   console.log(html);
+     * });
+     * ```
+     *
+     * @param userFunc User function to be executed. If it returns a promise,
+     * the promise will be awaited. The user function is called with no arguments.
+     * @param options
+     * @ignore
+     */
+    main(userFunc, options) {
+        if (!userFunc || typeof userFunc !== 'function') {
+            throw new Error(`First parameter for Actor.main() must be a function (was '${userFunc === null ? 'null' : typeof userFunc}').`);
+        }
+        return (async () => {
+            if (options?.purge) {
+                await (0, utils_1.purgeLocalStorage)();
+            }
+            await this.init();
+            let ret;
+            try {
+                ret = await core_1.Configuration.storage.run(this.config, userFunc);
+                await this.exit(options);
+            }
+            catch (err) {
+                log_1.default.exception(err, err.message);
+                await this.exit({ exitCode: exports.EXIT_CODES.ERROR_USER_FUNCTION_THREW });
+            }
+            return ret;
+        })();
+    }
+    /**
+     * @ignore
+     */
+    async init() {
+        (0, utils_2.logSystemInfo)();
+        (0, utils_2.printOutdatedSdkWarning)();
+        await this.eventManager.init();
+        if (this.isAtHome()) {
+            this.config.set('availableMemoryRatio', 1);
+            this.config.useStorageClient(this.apifyClient);
+            this.config.useEventManager(this.eventManager);
+        }
+    }
+    /**
+     * @ignore
+     */
+    async exit(options = {}) {
+        await this.eventManager.close();
+        if (options.exit ?? true) {
+            process.exit(options.exitCode ?? exports.EXIT_CODES.SUCCESS);
+        }
+    }
+    /**
+     * @ignore
+     */
+    on(event, listener) {
+        this.eventManager.on(event, listener);
+    }
+    /**
+     * @ignore
+     */
+    off(event, listener) {
+        this.eventManager.off(event, listener);
+    }
+    /**
+     * Runs an actor on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * waits for the actor to finish and fetches its output.
+     *
+     * By passing the `waitSecs` option you can reduce the maximum amount of time to wait for the run to finish.
+     * If the value is less than or equal to zero, the function returns immediately after the run is started.
+     *
+     * The result of the function is an {@link ActorRun} object
+     * that contains details about the actor run and its output (if any).
+     *
+     * If you want to run an actor task rather than an actor, please use the
+     * {@link Actor.callTask} function instead.
+     *
+     * For more information about actors, read the
+     * [documentation](https://docs.apify.com/actor).
+     *
+     * **Example usage:**
+     *
+     * ```javascript
+     * const run = await Actor.call('apify/hello-world', { myInput: 123 });
+     * console.log(`Received message: ${run.output.body.message}`);
+     * ```
+     *
+     * Internally, the `call()` function invokes the
+     * [Run actor](https://apify.com/docs/api/v2#/reference/actors/run-collection/run-actor)
+     * and several other API endpoints to obtain the output.
+     *
+     * @param actId
+     *  Allowed formats are `username/actor-name`, `userId/actor-name` or actor ID.
+     * @param [input]
+     *  Input for the actor. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Otherwise the `options.contentType` parameter must be provided.
+     * @param [options]
+     * @ignore
+     */
+    async call(actId, input, options = {}) {
+        const { token, ...rest } = options;
+        const client = token ? this.newClient({ token }) : this.apifyClient;
+        return client.actor(actId).call(input, rest);
+    }
+    /**
+     * Runs an actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * waits for the task to finish and fetches its output.
+     *
+     * By passing the `waitSecs` option you can reduce the maximum amount of time to wait for the run to finish.
+     * If the value is less than or equal to zero, the function returns immediately after the run is started.
+     *
+     * The result of the function is an {@link ActorRun} object
+     * that contains details about the actor run and its output (if any).
+     *
+     * Note that an actor task is a saved input configuration and options for an actor.
+     * If you want to run an actor directly rather than an actor task, please use the
+     * {@link Actor.call} function instead.
+     *
+     * For more information about actor tasks, read the [documentation](https://docs.apify.com/tasks).
+     *
+     * **Example usage:**
+     *
+     * ```javascript
+     * const run = await Actor.callTask('bob/some-task');
+     * console.log(`Received message: ${run.output.body.message}`);
+     * ```
+     *
+     * Internally, the `callTask()` function calls the
+     * [Run task](https://apify.com/docs/api/v2#/reference/actor-tasks/run-collection/run-task)
+     * and several other API endpoints to obtain the output.
+     *
+     * @param taskId
+     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
+     * @param [input]
+     *  Input overrides for the actor task. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Provided input will be merged with actor task input.
+     * @param [options]
+     * @ignore
+     */
+    async callTask(taskId, input, options = {}) {
+        const { token, ...rest } = options;
+        const client = token ? this.newClient({ token }) : this.apifyClient;
+        return client.task(taskId).call(input, rest);
+    }
+    /**
+     * Transforms this actor run to an actor run of a given actor. The system stops the current container and starts
+     * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key
+     * in the same default key-value store.
+     *
+     * @param targetActorId
+     *  Either `username/actor-name` or actor ID of an actor to which we want to metamorph.
+     * @param [input]
+     *  Input for the actor. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Otherwise, the `options.contentType` parameter must be provided.
+     * @param [options]
+     * @ignore
+     */
+    async metamorph(targetActorId, input, options = {}) {
+        if (!this.isAtHome()) {
+            log_1.default.warning('Actor.metamorph() is only supported when running on the Apify platform.');
+            return;
+        }
+        const { customAfterSleepMillis = this.config.get('metamorphAfterSleepMillis'), ...metamorphOpts } = options;
+        const runId = this.config.get('actorRunId');
+        await this.apifyClient.run(runId).metamorph(targetActorId, input, metamorphOpts);
+        // Wait some time for container to be stopped.
+        await (0, utils_1.sleep)(customAfterSleepMillis);
+    }
+    /**
+     * Internally reboots this actor. The system stops the current container and starts
+     * a new container with the same run ID.
+     *
+     * @ignore
+     */
+    async reboot() {
+        if (!this.isAtHome()) {
+            log_1.default.warning('Actor.reboot() is only supported when running on the Apify platform.');
+            return;
+        }
+        // Waiting for all the listeners to finish, as `.metamorph()` kills the container.
+        await Promise.all([
+            // `persistState` for individual RequestLists, RequestQueue... instances to be persisted
+            ...this.config.getEventManager().listeners("persistState" /* PERSIST_STATE */).map((x) => x()),
+            // `migrating` to pause Apify crawlers
+            ...this.config.getEventManager().listeners("migrating" /* MIGRATING */).map((x) => x()),
+        ]);
+        const actorId = this.config.get('actorId');
+        await this.metamorph(actorId);
+    }
+    /**
+     * Creates an ad-hoc webhook for the current actor run, which lets you receive a notification when the actor run finished or failed.
+     * For more information about Apify actor webhooks, please see the [documentation](https://docs.apify.com/webhooks).
+     *
+     * Note that webhooks are only supported for actors running on the Apify platform.
+     * In local environment, the function will print a warning and have no effect.
+     *
+     * @param options
+     * @returns The return value is the Webhook object.
+     * For more information, see the [Get webhook](https://apify.com/docs/api/v2#/reference/webhooks/webhook-object/get-webhook) API endpoint.
+     * @ignore
+     */
+    async addWebhook(options) {
+        (0, ow_1.default)(options, ow_1.default.object.exactShape({
+            eventTypes: ow_1.default.array.ofType(ow_1.default.string),
+            requestUrl: ow_1.default.string,
+            payloadTemplate: ow_1.default.optional.string,
+            idempotencyKey: ow_1.default.optional.string,
+        }));
+        const { eventTypes, requestUrl, payloadTemplate, idempotencyKey } = options;
+        if (!this.isAtHome()) {
+            log_1.default.warning('Actor.addWebhook() is only supported when running on the Apify platform. The webhook will not be invoked.');
+            return undefined;
+        }
+        const runId = this.config.get('actorRunId');
+        if (!runId) {
+            throw new Error(`Environment variable ${consts_1.ENV_VARS.ACTOR_RUN_ID} is not set!`);
+        }
+        return this.apifyClient.webhooks().create({
+            isAdHoc: true,
+            eventTypes,
+            condition: {
+                actorRunId: runId,
+            },
+            requestUrl,
+            payloadTemplate,
+            idempotencyKey,
+        });
+    }
+    /**
+     * Stores an object or an array of objects to the default {@link Dataset} of the current actor run.
+     *
+     * This is just a convenient shortcut for {@link Dataset.pushData}.
+     * For example, calling the following code:
+     * ```javascript
+     * await Actor.pushData({ myValue: 123 });
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const dataset = await Actor.openDataset();
+     * await dataset.pushData({ myValue: 123 });
+     * ```
+     *
+     * For more information, see {@link Actor.openDataset} and {@link Dataset.pushData}
+     *
+     * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
+     * otherwise the actor process might finish before the data are stored!
+     *
+     * @param item Object or array of objects containing data to be stored in the default dataset.
+     * The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
+     * @ignore
+     */
+    async pushData(item) {
+        const dataset = await this.openDataset();
+        return dataset.pushData(item);
+    }
+    /**
+     * Opens a dataset and returns a promise resolving to an instance of the {@link Dataset} class.
+     *
+     * Datasets are used to store structured data where each object stored has the same attributes,
+     * such as online store products or real estate offers.
+     * The actual data is stored either on the local filesystem or in the cloud.
+     *
+     * For more details and code examples, see the {@link Dataset} class.
+     *
+     * @param [datasetIdOrName]
+     *   ID or name of the dataset to be opened. If `null` or `undefined`,
+     *   the function returns the default dataset associated with the actor run.
+     * @param [options]
+     * @ignore
+     */
+    async openDataset(datasetIdOrName, options = {}) {
+        (0, ow_1.default)(datasetIdOrName, ow_1.default.optional.string);
+        (0, ow_1.default)(options, ow_1.default.object.exactShape({
+            forceCloud: ow_1.default.optional.boolean,
+        }));
+        return this._openStorage(core_1.Dataset, datasetIdOrName, options);
+    }
+    /**
+     * Gets a value from the default {@link KeyValueStore} associated with the current actor run.
+     *
+     * This is just a convenient shortcut for {@link KeyValueStore.getValue}.
+     * For example, calling the following code:
+     * ```javascript
+     * const value = await Actor.getValue('my-key');
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const store = await Actor.openKeyValueStore();
+     * const value = await store.getValue('my-key');
+     * ```
+     *
+     * To store the value to the default key-value store, you can use the {@link Actor.setValue} function.
+     *
+     * For more information, see  {@link Actor.openKeyValueStore}
+     * and  {@link KeyValueStore.getValue}.
+     *
+     * @param key Unique record key.
+     * @returns
+     *   Returns a promise that resolves to an object, string
+     *   or [`Buffer`](https://nodejs.org/api/buffer.html), depending
+     *   on the MIME content type of the record, or `null`
+     *   if the record is missing.
+     * @ignore
+     */
+    async getValue(key) {
+        const store = await this.openKeyValueStore();
+        return store.getValue(key);
+    }
+    /**
+     * Stores or deletes a value in the default {@link KeyValueStore} associated with the current actor run.
+     *
+     * This is just a convenient shortcut for  {@link KeyValueStore.setValue}.
+     * For example, calling the following code:
+     * ```javascript
+     * await Actor.setValue('OUTPUT', { foo: "bar" });
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const store = await Actor.openKeyValueStore();
+     * await store.setValue('OUTPUT', { foo: "bar" });
+     * ```
+     *
+     * To get a value from the default key-value store, you can use the  {@link Actor.getValue} function.
+     *
+     * For more information, see  {@link Actor.openKeyValueStore}
+     * and  {@link KeyValueStore.getValue}.
+     *
+     * @param key
+     *   Unique record key.
+     * @param value
+     *   Record data, which can be one of the following values:
+     *    - If `null`, the record in the key-value store is deleted.
+     *    - If no `options.contentType` is specified, `value` can be any JavaScript object, and it will be stringified to JSON.
+     *    - If `options.contentType` is set, `value` is taken as is, and it must be a `String` or [`Buffer`](https://nodejs.org/api/buffer.html).
+     *   For any other value an error will be thrown.
+     * @param [options]
+     * @ignore
+     */
+    async setValue(key, value, options = {}) {
+        const store = await this.openKeyValueStore();
+        return store.setValue(key, value, options);
+    }
+    /**
+     * Gets the actor input value from the default {@link KeyValueStore} associated with the current actor run.
+     *
+     * This is just a convenient shortcut for [`keyValueStore.getValue('INPUT')`](core/class/KeyValueStore#getValue).
+     * For example, calling the following code:
+     * ```javascript
+     * const input = await Actor.getInput();
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const store = await Actor.openKeyValueStore();
+     * await store.getValue('INPUT');
+     * ```
+     *
+     * Note that the `getInput()` function does not cache the value read from the key-value store.
+     * If you need to use the input multiple times in your actor,
+     * it is far more efficient to read it once and store it locally.
+     *
+     * For more information, see  {@link Actor.openKeyValueStore}
+     * and {@link KeyValueStore.getValue}.
+     *
+     * @returns
+     *   Returns a promise that resolves to an object, string
+     *   or [`Buffer`](https://nodejs.org/api/buffer.html), depending
+     *   on the MIME content type of the record, or `null`
+     *   if the record is missing.
+     * @ignore
+     */
+    async getInput() {
+        return this.getValue(this.config.get('inputKey'));
+    }
+    /**
+     * Opens a key-value store and returns a promise resolving to an instance of the {@link KeyValueStore} class.
+     *
+     * Key-value stores are used to store records or files, along with their MIME content type.
+     * The records are stored and retrieved using a unique key.
+     * The actual data is stored either on a local filesystem or in the Apify cloud.
+     *
+     * For more details and code examples, see the {@link KeyValueStore} class.
+     *
+     * @param [storeIdOrName]
+     *   ID or name of the key-value store to be opened. If `null` or `undefined`,
+     *   the function returns the default key-value store associated with the actor run.
+     * @param [options]
+     * @ignore
+     */
+    async openKeyValueStore(storeIdOrName, options = {}) {
+        (0, ow_1.default)(storeIdOrName, ow_1.default.optional.string);
+        (0, ow_1.default)(options, ow_1.default.object.exactShape({
+            forceCloud: ow_1.default.optional.boolean,
+        }));
+        return this._openStorage(core_1.KeyValueStore, storeIdOrName, options);
+    }
+    /**
+     * Opens a request list and returns a promise resolving to an instance
+     * of the {@link RequestList} class that is already initialized.
+     *
+     * {@link RequestList} represents a list of URLs to crawl, which is always stored in memory.
+     * To enable picking up where left off after a process restart, the request list sources
+     * are persisted to the key-value store at initialization of the list. Then, while crawling,
+     * a small state object is regularly persisted to keep track of the crawling status.
+     *
+     * For more details and code examples, see the {@link RequestList} class.
+     *
+     * **Example usage:**
+     *
+     * ```javascript
+     * const sources = [
+     *     'https://www.example.com',
+     *     'https://www.google.com',
+     *     'https://www.bing.com'
+     * ];
+     *
+     * const requestList = await RequestList.open('my-name', sources);
+     * ```
+     *
+     * @param listName
+     *   Name of the request list to be opened. Setting a name enables the `RequestList`'s state to be persisted
+     *   in the key-value store. This is useful in case of a restart or migration. Since `RequestList` is only
+     *   stored in memory, a restart or migration wipes it clean. Setting a name will enable the `RequestList`'s
+     *   state to survive those situations and continue where it left off.
+     *
+     *   The name will be used as a prefix in key-value store, producing keys such as `NAME-REQUEST_LIST_STATE`
+     *   and `NAME-REQUEST_LIST_SOURCES`.
+     *
+     *   If `null`, the list will not be persisted and will only be stored in memory. Process restart
+     *   will then cause the list to be crawled again from the beginning. We suggest always using a name.
+     * @param sources
+     *  An array of sources of URLs for the {@link RequestList}. It can be either an array of strings,
+     *  plain objects that define at least the `url` property, or an array of {@link Request} instances.
+     *
+     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@link RequestList} initializes.
+     *  This is a measure to prevent memory leaks in situations when millions of sources are
+     *  added.
+     *
+     *  Additionally, the `requestsFromUrl` property may be used instead of `url`,
+     *  which will instruct {@link RequestList} to download the source URLs from a given remote location.
+     *  The URLs will be parsed from the received response. In this case you can limit the URLs
+     *  using `regex` parameter containing regular expression pattern for URLs to be included.
+     *
+     *  For details, see the {@link RequestListOptions.sources}
+     * @param [options]
+     *   The {@link RequestList} options. Note that the `listName` parameter supersedes
+     *   the {@link RequestListOptions.persistStateKey} and {@link RequestListOptions.persistRequestsKey}
+     *   options and the `sources` parameter supersedes the {@link RequestListOptions.sources} option.
+     * @ignore
+     */
+    async openRequestList(listName, sources, options = {}) {
+        return core_1.RequestList.open(listName, sources, options);
+    }
+    /**
+     * Opens a request queue and returns a promise resolving to an instance
+     * of the {@link RequestQueue} class.
+     *
+     * {@link RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
+     * The queue is used for deep crawling of websites, where you start with several URLs and then
+     * recursively follow links to other pages. The data structure supports both breadth-first
+     * and depth-first crawling orders.
+     *
+     * For more details and code examples, see the {@link RequestQueue} class.
+     *
+     * @param [queueIdOrName]
+     *   ID or name of the request queue to be opened. If `null` or `undefined`,
+     *   the function returns the default request queue associated with the actor run.
+     * @param [options]
+     * @ignore
+     */
+    async openRequestQueue(queueIdOrName, options = {}) {
+        (0, ow_1.default)(queueIdOrName, ow_1.default.optional.string);
+        (0, ow_1.default)(options, ow_1.default.object.exactShape({
+            forceCloud: ow_1.default.optional.boolean,
+        }));
+        return this._openStorage(core_1.RequestQueue, queueIdOrName, options);
+    }
+    /**
+     * Creates a proxy configuration and returns a promise resolving to an instance
+     * of the {@link ProxyConfiguration} class that is already initialized.
+     *
+     * Configures connection to a proxy server with the provided options. Proxy servers are used to prevent target websites from blocking
+     * your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
+     * them to use the selected proxies for all connections.
+     *
+     * For more details and code examples, see the {@link ProxyConfiguration} class.
+     *
+     * ```javascript
+     *
+     * // Returns initialized proxy configuration class
+     * const proxyConfiguration = await Actor.createProxyConfiguration({
+     *     groups: ['GROUP1', 'GROUP2'] // List of Apify proxy groups
+     *     countryCode: 'US'
+     * });
+     *
+     * const crawler = new CheerioCrawler({
+     *   // ...
+     *   proxyConfiguration,
+     *   handlePageFunction: ({ proxyInfo }) => {
+     *       const usedProxyUrl = proxyInfo.url; // Getting the proxy URL
+     *   }
+     * })
+     *
+     * ```
+     *
+     * For compatibility with existing Actor Input UI (Input Schema), this function
+     * returns `undefined` when the following object is passed as `proxyConfigurationOptions`.
+     *
+     * ```
+     * { useApifyProxy: false }
+     * ```
+     * @ignore
+     */
+    async createProxyConfiguration(proxyConfigurationOptions = {}) {
+        // Compatibility fix for Input UI where proxy: None returns { useApifyProxy: false }
+        // Without this, it would cause proxy to use the zero config / auto mode.
+        const dontUseApifyProxy = proxyConfigurationOptions.useApifyProxy === false;
+        const dontUseCustomProxies = !proxyConfigurationOptions.proxyUrls;
+        if (dontUseApifyProxy && dontUseCustomProxies) {
+            return undefined;
+        }
+        const proxyConfiguration = new proxy_configuration_1.ProxyConfiguration(proxyConfigurationOptions, this.config);
+        await proxyConfiguration.initialize();
+        return proxyConfiguration;
+    }
+    /**
+     * Returns a new {@link ApifyEnv} object which contains information parsed from all the `APIFY_XXX` environment variables.
+     *
+     * For the list of the `APIFY_XXX` environment variables, see
+     * [Actor documentation](https://docs.apify.com/actor/run#environment-variables).
+     * If some variables are not defined or are invalid, the corresponding value in the resulting object will be null.
+     * @ignore
+     */
+    getEnv() {
+        // NOTE: Don't throw if env vars are invalid to simplify local development and debugging of actors
+        const env = process.env || {};
+        const envVars = {};
+        for (const [shortName, fullName] of Object.entries(consts_1.ENV_VARS)) {
+            const camelCaseName = (0, utils_1.snakeCaseToCamelCase)(shortName);
+            let value = env[fullName];
+            // Parse dates and integers.
+            if (value && fullName.endsWith('_AT')) {
+                const unix = Date.parse(value);
+                value = unix > 0 ? new Date(unix) : undefined;
+            }
+            else if (consts_1.INTEGER_ENV_VARS.includes(fullName)) {
+                value = parseInt(value, 10);
+            }
+            Reflect.set(envVars, camelCaseName, value || value === 0 ? value : null);
+        }
+        return envVars;
+    }
+    /**
+     * Returns a new instance of the Apify API client. The `ApifyClient` class is provided
+     * by the [apify-client](https://www.npmjs.com/package/apify-client)
+     * NPM package, and it is automatically configured using the `APIFY_API_BASE_URL`, and `APIFY_TOKEN`
+     * environment variables. You can override the token via the available options. That's useful
+     * if you want to use the client as a different Apify user than the SDK internals are using.
+     * @ignore
+     */
+    newClient(options = {}) {
+        const { storageDir, ...storageClientOptions } = this.config.get('storageClientOptions');
+        return new apify_client_1.ApifyClient({
+            baseUrl: process.env[consts_1.ENV_VARS.API_BASE_URL] ?? 'https://api.apify.com',
+            token: process.env[consts_1.ENV_VARS.TOKEN],
+            ...storageClientOptions,
+            ...options, // allow overriding the instance configuration
+        });
+    }
+    /**
+     * Returns `true` when code is running on Apify platform and `false` otherwise (for example locally).
+     * @ignore
+     */
+    isAtHome() {
+        return !!process.env[consts_1.ENV_VARS.IS_AT_HOME];
+    }
+    /**
+     * Runs the main user function that performs the job of the actor
+     * and terminates the process when the user function finishes.
+     *
+     * **The `Actor.main()` function is optional** and is provided merely for your convenience.
+     * It is mainly useful when you're running your code as an actor on the [Apify platform](https://apify.com/actors).
+     * However, if you want to use Apify SDK tools directly inside your existing projects, e.g.
+     * running in an [Express](https://expressjs.com/) server, on
+     * [Google Cloud functions](https://cloud.google.com/functions)
+     * or [AWS Lambda](https://aws.amazon.com/lambda/), it's better to avoid
+     * it since the function terminates the main process when it finishes!
+     *
+     * The `Actor.main()` function performs the following actions:
+     *
+     * - When running on the Apify platform (i.e. `APIFY_IS_AT_HOME` environment variable is set),
+     *   it sets up a connection to listen for platform events.
+     *   For example, to get a notification about an imminent migration to another server.
+     *   See {@link Actor.events} for details.
+     * - It checks that either `APIFY_TOKEN` or `APIFY_LOCAL_STORAGE_DIR` environment variable
+     *   is defined. If not, the functions sets `APIFY_LOCAL_STORAGE_DIR` to `./apify_storage`
+     *   inside the current working directory. This is to simplify running code examples.
+     * - It invokes the user function passed as the `userFunc` parameter.
+     * - If the user function returned a promise, waits for it to resolve.
+     * - If the user function throws an exception or some other error is encountered,
+     *   prints error details to console so that they are stored to the log.
+     * - Exits the Node.js process, with zero exit code on success and non-zero on errors.
+     *
+     * The user function can be synchronous:
+     *
+     * ```javascript
+     * Actor.main(() => {
+     *   // My synchronous function that returns immediately
+     *   console.log('Hello world from actor!');
+     * });
+     * ```
+     *
+     * If the user function returns a promise, it is considered asynchronous:
+     * ```javascript
+     * const { gotScraping } = require('got-scraping');
+     *
+     * Actor.main(() => {
+     *   // My asynchronous function that returns a promise
+     *   return gotScraping('http://www.example.com').then((html) => {
+     *     console.log(html);
+     *   });
+     * });
+     * ```
+     *
+     * To simplify your code, you can take advantage of the `async`/`await` keywords:
+     *
+     * ```javascript
+     * const { gotScraping } = require('got-scraping');
+     *
+     * Actor.main(async () => {
+     *   // My asynchronous function
+     *   const html = await gotScraping('http://www.example.com');
+     *   console.log(html);
+     * });
+     * ```
+     *
+     * @param userFunc User function to be executed. If it returns a promise,
+     * the promise will be awaited. The user function is called with no arguments.
+     * @param options
+     */
+    static main(userFunc, options) {
+        return Actor.getDefaultInstance().main(userFunc, options);
+    }
+    static async init() {
+        return Actor.getDefaultInstance().init();
+    }
+    static async exit(options = {}) {
+        return Actor.getDefaultInstance().exit(options);
+    }
+    static on(event, listener) {
+        Actor.getDefaultInstance().on(event, listener);
+    }
+    static off(event, listener) {
+        Actor.getDefaultInstance().off(event, listener);
+    }
+    /**
+     * Runs an actor on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * waits for the actor to finish and fetches its output.
+     *
+     * By passing the `waitSecs` option you can reduce the maximum amount of time to wait for the run to finish.
+     * If the value is less than or equal to zero, the function returns immediately after the run is started.
+     *
+     * The result of the function is an {@link ActorRun} object
+     * that contains details about the actor run and its output (if any).
+     *
+     * If you want to run an actor task rather than an actor, please use the
+     * {@link Actor.callTask} function instead.
+     *
+     * For more information about actors, read the
+     * [documentation](https://docs.apify.com/actor).
+     *
+     * **Example usage:**
+     *
+     * ```javascript
+     * const run = await Actor.call('apify/hello-world', { myInput: 123 });
+     * console.log(`Received message: ${run.output.body.message}`);
+     * ```
+     *
+     * Internally, the `call()` function invokes the
+     * [Run actor](https://apify.com/docs/api/v2#/reference/actors/run-collection/run-actor)
+     * and several other API endpoints to obtain the output.
+     *
+     * @param actId
+     *  Allowed formats are `username/actor-name`, `userId/actor-name` or actor ID.
+     * @param [input]
+     *  Input for the actor. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Otherwise the `options.contentType` parameter must be provided.
+     * @param [options]
+     */
+    static async call(actId, input, options = {}) {
+        return Actor.getDefaultInstance().call(actId, input, options);
+    }
+    /**
+     * Runs an actor task on the Apify platform using the current user account (determined by the `APIFY_TOKEN` environment variable),
+     * waits for the task to finish and fetches its output.
+     *
+     * By passing the `waitSecs` option you can reduce the maximum amount of time to wait for the run to finish.
+     * If the value is less than or equal to zero, the function returns immediately after the run is started.
+     *
+     * The result of the function is an {@link ActorRun} object
+     * that contains details about the actor run and its output (if any).
+     *
+     * Note that an actor task is a saved input configuration and options for an actor.
+     * If you want to run an actor directly rather than an actor task, please use the
+     * {@link Actor.call} function instead.
+     *
+     * For more information about actor tasks, read the [documentation](https://docs.apify.com/tasks).
+     *
+     * **Example usage:**
+     *
+     * ```javascript
+     * const run = await Actor.callTask('bob/some-task');
+     * console.log(`Received message: ${run.output.body.message}`);
+     * ```
+     *
+     * Internally, the `callTask()` function calls the
+     * [Run task](https://apify.com/docs/api/v2#/reference/actor-tasks/run-collection/run-task)
+     * and several other API endpoints to obtain the output.
+     *
+     * @param taskId
+     *  Allowed formats are `username/task-name`, `userId/task-name` or task ID.
+     * @param [input]
+     *  Input overrides for the actor task. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Provided input will be merged with actor task input.
+     * @param [options]
+     */
+    static async callTask(taskId, input, options = {}) {
+        return Actor.getDefaultInstance().callTask(taskId, input, options);
+    }
+    /**
+     * Transforms this actor run to an actor run of a given actor. The system stops the current container and starts
+     * the new container instead. All the default storages are preserved and the new input is stored under the `INPUT-METAMORPH-1` key
+     * in the same default key-value store.
+     *
+     * @param targetActorId
+     *  Either `username/actor-name` or actor ID of an actor to which we want to metamorph.
+     * @param [input]
+     *  Input for the actor. If it is an object, it will be stringified to
+     *  JSON and its content type set to `application/json; charset=utf-8`.
+     *  Otherwise, the `options.contentType` parameter must be provided.
+     * @param [options]
+     */
+    static async metamorph(targetActorId, input, options = {}) {
+        return Actor.getDefaultInstance().metamorph(targetActorId, input, options);
+    }
+    /**
+     * Internally reboots this actor run. The system stops the current container and starts
+     * a new container with the same run id.
+     */
+    static async reboot() {
+        return Actor.getDefaultInstance().reboot();
+    }
+    /**
+     * Creates an ad-hoc webhook for the current actor run, which lets you receive a notification when the actor run finished or failed.
+     * For more information about Apify actor webhooks, please see the [documentation](https://docs.apify.com/webhooks).
+     *
+     * Note that webhooks are only supported for actors running on the Apify platform.
+     * In local environment, the function will print a warning and have no effect.
+     *
+     * @param options
+     * @returns The return value is the Webhook object.
+     * For more information, see the [Get webhook](https://apify.com/docs/api/v2#/reference/webhooks/webhook-object/get-webhook) API endpoint.
+     */
+    static async addWebhook(options) {
+        return Actor.getDefaultInstance().addWebhook(options);
+    }
+    /**
+     * Stores an object or an array of objects to the default {@link Dataset} of the current actor run.
+     *
+     * This is just a convenient shortcut for {@link Dataset.pushData}.
+     * For example, calling the following code:
+     * ```javascript
+     * await Actor.pushData({ myValue: 123 });
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const dataset = await Actor.openDataset();
+     * await dataset.pushData({ myValue: 123 });
+     * ```
+     *
+     * For more information, see {@link Actor.openDataset} and {@link Dataset.pushData}
+     *
+     * **IMPORTANT**: Make sure to use the `await` keyword when calling `pushData()`,
+     * otherwise the actor process might finish before the data are stored!
+     *
+     * @param item Object or array of objects containing data to be stored in the default dataset.
+     * The objects must be serializable to JSON and the JSON representation of each object must be smaller than 9MB.
+     */
+    static async pushData(item) {
+        return Actor.getDefaultInstance().pushData(item);
+    }
+    /**
+     * Opens a dataset and returns a promise resolving to an instance of the {@link Dataset} class.
+     *
+     * Datasets are used to store structured data where each object stored has the same attributes,
+     * such as online store products or real estate offers.
+     * The actual data is stored either on the local filesystem or in the cloud.
+     *
+     * For more details and code examples, see the {@link Dataset} class.
+     *
+     * @param [datasetIdOrName]
+     *   ID or name of the dataset to be opened. If `null` or `undefined`,
+     *   the function returns the default dataset associated with the actor run.
+     * @param [options]
+     */
+    static async openDataset(datasetIdOrName, options = {}) {
+        return Actor.getDefaultInstance().openDataset(datasetIdOrName, options);
+    }
+    /**
+     * Gets a value from the default {@link KeyValueStore} associated with the current actor run.
+     *
+     * This is just a convenient shortcut for {@link KeyValueStore.getValue}.
+     * For example, calling the following code:
+     * ```javascript
+     * const value = await Actor.getValue('my-key');
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const store = await Actor.openKeyValueStore();
+     * const value = await store.getValue('my-key');
+     * ```
+     *
+     * To store the value to the default key-value store, you can use the {@link Actor.setValue} function.
+     *
+     * For more information, see  {@link Actor.openKeyValueStore}
+     * and  {@link KeyValueStore.getValue}.
+     *
+     * @param key Unique record key.
+     * @returns
+     *   Returns a promise that resolves to an object, string
+     *   or [`Buffer`](https://nodejs.org/api/buffer.html), depending
+     *   on the MIME content type of the record, or `null`
+     *   if the record is missing.
+     */
+    static async getValue(key) {
+        return Actor.getDefaultInstance().getValue(key);
+    }
+    /**
+     * Stores or deletes a value in the default {@link KeyValueStore} associated with the current actor run.
+     *
+     * This is just a convenient shortcut for  {@link KeyValueStore.setValue}.
+     * For example, calling the following code:
+     * ```javascript
+     * await Actor.setValue('OUTPUT', { foo: "bar" });
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const store = await Actor.openKeyValueStore();
+     * await store.setValue('OUTPUT', { foo: "bar" });
+     * ```
+     *
+     * To get a value from the default key-value store, you can use the  {@link Actor.getValue} function.
+     *
+     * For more information, see  {@link Actor.openKeyValueStore}
+     * and  {@link KeyValueStore.getValue}.
+     *
+     * @param key
+     *   Unique record key.
+     * @param value
+     *   Record data, which can be one of the following values:
+     *    - If `null`, the record in the key-value store is deleted.
+     *    - If no `options.contentType` is specified, `value` can be any JavaScript object, and it will be stringified to JSON.
+     *    - If `options.contentType` is set, `value` is taken as is, and it must be a `String` or [`Buffer`](https://nodejs.org/api/buffer.html).
+     *   For any other value an error will be thrown.
+     * @param [options]
+     */
+    static async setValue(key, value, options = {}) {
+        return Actor.getDefaultInstance().setValue(key, value, options);
+    }
+    /**
+     * Gets the actor input value from the default {@link KeyValueStore} associated with the current actor run.
+     *
+     * This is just a convenient shortcut for {@link KeyValueStore.getValue | `keyValueStore.getValue('INPUT')`}.
+     * For example, calling the following code:
+     * ```javascript
+     * const input = await Actor.getInput();
+     * ```
+     *
+     * is equivalent to:
+     * ```javascript
+     * const store = await Actor.openKeyValueStore();
+     * await store.getValue('INPUT');
+     * ```
+     *
+     * Note that the `getInput()` function does not cache the value read from the key-value store.
+     * If you need to use the input multiple times in your actor,
+     * it is far more efficient to read it once and store it locally.
+     *
+     * For more information, see {@link Actor.openKeyValueStore} and {@link KeyValueStore.getValue}.
+     *
+     * @returns
+     *   Returns a promise that resolves to an object, string
+     *   or [`Buffer`](https://nodejs.org/api/buffer.html), depending
+     *   on the MIME content type of the record, or `null`
+     *   if the record is missing.
+     */
+    static async getInput() {
+        return Actor.getDefaultInstance().getInput();
+    }
+    /**
+     * Opens a key-value store and returns a promise resolving to an instance of the {@link KeyValueStore} class.
+     *
+     * Key-value stores are used to store records or files, along with their MIME content type.
+     * The records are stored and retrieved using a unique key.
+     * The actual data is stored either on a local filesystem or in the Apify cloud.
+     *
+     * For more details and code examples, see the {@link KeyValueStore} class.
+     *
+     * @param [storeIdOrName]
+     *   ID or name of the key-value store to be opened. If `null` or `undefined`,
+     *   the function returns the default key-value store associated with the actor run.
+     * @param [options]
+     */
+    static async openKeyValueStore(storeIdOrName, options = {}) {
+        return Actor.getDefaultInstance().openKeyValueStore(storeIdOrName, options);
+    }
+    /**
+     * Opens a request list and returns a promise resolving to an instance
+     * of the {@link RequestList} class that is already initialized.
+     *
+     * {@link RequestList} represents a list of URLs to crawl, which is always stored in memory.
+     * To enable picking up where left off after a process restart, the request list sources
+     * are persisted to the key-value store at initialization of the list. Then, while crawling,
+     * a small state object is regularly persisted to keep track of the crawling status.
+     *
+     * For more details and code examples, see the {@link RequestList} class.
+     *
+     * **Example usage:**
+     *
+     * ```javascript
+     * const sources = [
+     *     'https://www.example.com',
+     *     'https://www.google.com',
+     *     'https://www.bing.com'
+     * ];
+     *
+     * const requestList = await RequestList.open('my-name', sources);
+     * ```
+     *
+     * @param listName
+     *   Name of the request list to be opened. Setting a name enables the `RequestList`'s state to be persisted
+     *   in the key-value store. This is useful in case of a restart or migration. Since `RequestList` is only
+     *   stored in memory, a restart or migration wipes it clean. Setting a name will enable the `RequestList`'s
+     *   state to survive those situations and continue where it left off.
+     *
+     *   The name will be used as a prefix in key-value store, producing keys such as `NAME-REQUEST_LIST_STATE`
+     *   and `NAME-REQUEST_LIST_SOURCES`.
+     *
+     *   If `null`, the list will not be persisted and will only be stored in memory. Process restart
+     *   will then cause the list to be crawled again from the beginning. We suggest always using a name.
+     * @param sources
+     *  An array of sources of URLs for the {@link RequestList}. It can be either an array of strings,
+     *  plain objects that define at least the `url` property, or an array of {@link Request} instances.
+     *
+     *  **IMPORTANT:** The `sources` array will be consumed (left empty) after {@link RequestList} initializes.
+     *  This is a measure to prevent memory leaks in situations when millions of sources are
+     *  added.
+     *
+     *  Additionally, the `requestsFromUrl` property may be used instead of `url`,
+     *  which will instruct {@link RequestList} to download the source URLs from a given remote location.
+     *  The URLs will be parsed from the received response. In this case you can limit the URLs
+     *  using `regex` parameter containing regular expression pattern for URLs to be included.
+     *
+     *  For details, see the {@link RequestListOptions.sources}
+     * @param [options]
+     *   The {@link RequestList} options. Note that the `listName` parameter supersedes
+     *   the {@link RequestListOptions.persistStateKey} and {@link RequestListOptions.persistRequestsKey}
+     *   options and the `sources` parameter supersedes the {@link RequestListOptions.sources} option.
+     */
+    static async openRequestList(listName, sources, options = {}) {
+        return Actor.getDefaultInstance().openRequestList(listName, sources, options);
+    }
+    /**
+     * Opens a request queue and returns a promise resolving to an instance
+     * of the {@link RequestQueue} class.
+     *
+     * {@link RequestQueue} represents a queue of URLs to crawl, which is stored either on local filesystem or in the cloud.
+     * The queue is used for deep crawling of websites, where you start with several URLs and then
+     * recursively follow links to other pages. The data structure supports both breadth-first
+     * and depth-first crawling orders.
+     *
+     * For more details and code examples, see the {@link RequestQueue} class.
+     *
+     * @param [queueIdOrName]
+     *   ID or name of the request queue to be opened. If `null` or `undefined`,
+     *   the function returns the default request queue associated with the actor run.
+     * @param [options]
+     */
+    static async openRequestQueue(queueIdOrName, options = {}) {
+        return Actor.getDefaultInstance().openRequestQueue(queueIdOrName, options);
+    }
+    /**
+     * Creates a proxy configuration and returns a promise resolving to an instance
+     * of the {@link ProxyConfiguration} class that is already initialized.
+     *
+     * Configures connection to a proxy server with the provided options. Proxy servers are used to prevent target websites from blocking
+     * your crawlers based on IP address rate limits or blacklists. Setting proxy configuration in your crawlers automatically configures
+     * them to use the selected proxies for all connections.
+     *
+     * For more details and code examples, see the {@link ProxyConfiguration} class.
+     *
+     * ```javascript
+     *
+     * // Returns initialized proxy configuration class
+     * const proxyConfiguration = await Actor.createProxyConfiguration({
+     *     groups: ['GROUP1', 'GROUP2'] // List of Apify proxy groups
+     *     countryCode: 'US'
+     * });
+     *
+     * const crawler = new CheerioCrawler({
+     *   // ...
+     *   proxyConfiguration,
+     *   handlePageFunction: ({ proxyInfo }) => {
+     *       const usedProxyUrl = proxyInfo.url; // Getting the proxy URL
+     *   }
+     * })
+     *
+     * ```
+     *
+     * For compatibility with existing Actor Input UI (Input Schema), this function
+     * returns `undefined` when the following object is passed as `proxyConfigurationOptions`.
+     *
+     * ```
+     * { useApifyProxy: false }
+     * ```
+     */
+    static async createProxyConfiguration(proxyConfigurationOptions = {}) {
+        return Actor.getDefaultInstance().createProxyConfiguration(proxyConfigurationOptions);
+    }
+    /**
+     * Returns a new {@link ApifyEnv} object which contains information parsed from all the `APIFY_XXX` environment variables.
+     *
+     * For the list of the `APIFY_XXX` environment variables, see
+     * [Actor documentation](https://docs.apify.com/actor/run#environment-variables).
+     * If some of the variables are not defined or are invalid, the corresponding value in the resulting object will be null.
+     */
+    static getEnv() {
+        return Actor.getDefaultInstance().getEnv();
+    }
+    /**
+     * Returns a new instance of the Apify API client. The `ApifyClient` class is provided
+     * by the [apify-client](https://www.npmjs.com/package/apify-client)
+     * NPM package, and it is automatically configured using the `APIFY_API_BASE_URL`, and `APIFY_TOKEN`
+     * environment variables. You can override the token via the available options. That's useful
+     * if you want to use the client as a different Apify user than the SDK internals are using.
+     */
+    static newClient(options = {}) {
+        return Actor.getDefaultInstance().newClient(options);
+    }
+    /**
+     * Returns `true` when code is running on Apify platform and `false` otherwise (for example locally).
+     */
+    static isAtHome() {
+        return Actor.getDefaultInstance().isAtHome();
+    }
+    /** Default {@link ApifyClient} instance. */
+    static get apifyClient() {
+        return Actor.getDefaultInstance().apifyClient;
+    }
+    /** Default {@link Configuration} instance. */
+    static get config() {
+        return Actor.getDefaultInstance().config;
+    }
+    /** @internal */
+    static getDefaultInstance() {
+        this._instance ?? (this._instance = new Actor());
+        return this._instance;
+    }
+    _openStorage(storageClass, id, options = {}) {
+        const client = options.forceCloud ? this.apifyClient : undefined;
+        return this._getStorageManager(storageClass).openStorage(id, client);
+    }
+    _getStorageManager(storageClass) {
+        if (!this.storageManagers.has(storageClass)) {
+            const manager = new core_1.StorageManager(storageClass, this.config);
+            this.storageManagers.set(storageClass, manager);
+        }
+        return this.storageManagers.get(storageClass);
+    }
+}
+exports.Actor = Actor;
+/**
+ * Exit codes for the actor process.
+ * The error codes must be in the range 1-128, to avoid collision with signal exits
+ * and to ensure Docker will handle them correctly!
+ * @internal should be removed if we decide to remove `Actor.main()`
+ */
+exports.EXIT_CODES = {
+    SUCCESS: 0,
+    ERROR_USER_FUNCTION_THREW: 91,
+    ERROR_UNKNOWN: 92,
+};
+//# sourceMappingURL=actor.js.map