@remotion/renderer 4.0.0-imgloading.2 → 4.0.0-lambda.1

package/dist/browser/JSHandle.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _JSHandle_client, _JSHandle_disposed, _JSHandle_context, _JSHandle_remoteObject;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementHandle = exports.JSHandle = exports._createJSHandle = void 0;
+const util_1 = require("./util");
+function _createJSHandle(context, remoteObject) {
+    const frame = context.frame();
+    if (remoteObject.subtype === 'node' && frame) {
+        return new ElementHandle(context, context._client, remoteObject);
+    }
+    return new JSHandle(context, context._client, remoteObject);
+}
+exports._createJSHandle = _createJSHandle;
+class JSHandle {
+    constructor(context, client, remoteObject) {
+        _JSHandle_client.set(this, void 0);
+        _JSHandle_disposed.set(this, false);
+        _JSHandle_context.set(this, void 0);
+        _JSHandle_remoteObject.set(this, void 0);
+        __classPrivateFieldSet(this, _JSHandle_context, context, "f");
+        __classPrivateFieldSet(this, _JSHandle_client, client, "f");
+        __classPrivateFieldSet(this, _JSHandle_remoteObject, remoteObject, "f");
+    }
+    get _client() {
+        return __classPrivateFieldGet(this, _JSHandle_client, "f");
+    }
+    get _disposed() {
+        return __classPrivateFieldGet(this, _JSHandle_disposed, "f");
+    }
+    get _remoteObject() {
+        return __classPrivateFieldGet(this, _JSHandle_remoteObject, "f");
+    }
+    get _context() {
+        return __classPrivateFieldGet(this, _JSHandle_context, "f");
+    }
+    executionContext() {
+        return __classPrivateFieldGet(this, _JSHandle_context, "f");
+    }
+    evaluateHandle(pageFunction, ...args) {
+        return this.executionContext().evaluateHandle(pageFunction, this, ...args);
+    }
+    asElement() {
+        return null;
+    }
+    async dispose() {
+        if (__classPrivateFieldGet(this, _JSHandle_disposed, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _JSHandle_disposed, true, "f");
+        await (0, util_1.releaseObject)(__classPrivateFieldGet(this, _JSHandle_client, "f"), __classPrivateFieldGet(this, _JSHandle_remoteObject, "f"));
+    }
+    toString() {
+        if (__classPrivateFieldGet(this, _JSHandle_remoteObject, "f").objectId) {
+            const type = __classPrivateFieldGet(this, _JSHandle_remoteObject, "f").subtype || __classPrivateFieldGet(this, _JSHandle_remoteObject, "f").type;
+            return 'JSHandle@' + type;
+        }
+        return 'JSHandle:' + (0, util_1.valueFromRemoteObject)(__classPrivateFieldGet(this, _JSHandle_remoteObject, "f"));
+    }
+}
+exports.JSHandle = JSHandle;
+_JSHandle_client = new WeakMap(), _JSHandle_disposed = new WeakMap(), _JSHandle_context = new WeakMap(), _JSHandle_remoteObject = new WeakMap();
+class ElementHandle extends JSHandle {
+    asElement() {
+        return this;
+    }
+}
+exports.ElementHandle = ElementHandle;

package/dist/browser/LaunchOptions.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BrowserConnectOptions } from './BrowserConnector';
+import { Product } from './Product';
+export interface BrowserLaunchArgumentOptions {
+    /**
+     * Whether to run the browser in headless mode.
+     * @defaultValue true
+     */
+    headless?: boolean | 'chrome';
+    /**
+     * Path to a user data directory.
+     * {@link https://chromium.googlesource.com/chromium/src/+/refs/heads/main/docs/user_data_dir.md | see the Chromium docs}
+     * for more info.
+     */
+    userDataDir?: string;
+    /**
+     * Whether to auto-open a DevTools panel for each tab. If this is set to
+     * `true`, then `headless` will be forced to `false`.
+     * @defaultValue `false`
+     */
+    devtools?: boolean;
+    /**
+     *
+     */
+    debuggingPort?: number;
+    /**
+     * Additional command line arguments to pass to the browser instance.
+     */
+    args: string[];
+}
+export declare type ChromeReleaseChannel = 'chrome' | 'chrome-beta' | 'chrome-canary' | 'chrome-dev';
+export interface LaunchOptions {
+    /**
+     * Chrome Release Channel
+     */
+    channel?: ChromeReleaseChannel;
+    /**
+     * Path to a browser executable to use instead of the bundled Chromium. Note
+     * that Puppeteer is only guaranteed to work with the bundled Chromium, so use
+     * this setting at your own risk.
+     */
+    executablePath?: string;
+    /**
+     * If `true`, do not use `puppeteer.defaultArgs()` when creating a browser. If
+     * an array is provided, these args will be filtered out. Use this with care -
+     * you probably want the default arguments Puppeteer uses.
+     * @defaultValue false
+     */
+    ignoreDefaultArgs?: boolean | string[];
+    /**
+     * Close the browser process on `Ctrl+C`.
+     * @defaultValue `true`
+     */
+    handleSIGINT?: boolean;
+    /**
+     * Close the browser process on `SIGTERM`.
+     * @defaultValue `true`
+     */
+    handleSIGTERM?: boolean;
+    /**
+     * Close the browser process on `SIGHUP`.
+     * @defaultValue `true`
+     */
+    handleSIGHUP?: boolean;
+    /**
+     * Maximum time in milliseconds to wait for the browser to start.
+     * Pass `0` to disable the timeout.
+     * @defaultValue 30000 (30 seconds).
+     */
+    timeout?: number;
+    /**
+     * If true, pipes the browser process stdout and stderr to `process.stdout`
+     * and `process.stderr`.
+     * @defaultValue false
+     */
+    dumpio?: boolean;
+    /**
+     * Specify environment variables that will be visible to the browser.
+     * @defaultValue The contents of `process.env`.
+     */
+    env?: Record<string, string | undefined>;
+    /**
+     * Connect to a browser over a pipe instead of a WebSocket.
+     * @defaultValue false
+     */
+    pipe?: boolean;
+    /**
+     * Which browser to launch.
+     * @defaultValue `chrome`
+     */
+    product?: Product;
+    /**
+     * {@link https://searchfox.org/mozilla-release/source/modules/libpref/init/all.js | Additional preferences } that can be passed when launching with Firefox.
+     */
+    extraPrefsFirefox?: Record<string, unknown>;
+    /**
+     * Whether to wait for the initial page to be ready.
+     * Useful when a user explicitly disables that (e.g. `--no-startup-window` for Chrome).
+     * @defaultValue true
+     */
+    waitForInitialPage?: boolean;
+}
+export declare type PuppeteerNodeLaunchOptions = BrowserLaunchArgumentOptions & LaunchOptions & BrowserConnectOptions;

package/dist/browser/LaunchOptions.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/browser/Launcher.d.ts

@@ -0,0 +1,9 @@
+import { Browser } from './Browser';
+import { PuppeteerNodeLaunchOptions } from './LaunchOptions';
+import { Product } from './Product';
+export interface ProductLauncher {
+    launch(object: PuppeteerNodeLaunchOptions): Promise<Browser>;
+    executablePath: (path?: any) => string;
+    product: Product;
+}
+export default function Launcher(preferredRevision: string, product?: string): ProductLauncher;