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

package/dist/browser/PipeTransport.js

@@ -0,0 +1,86 @@
+"use strict";
+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 _PipeTransport_instances, _PipeTransport_pipeWrite, _PipeTransport_eventListeners, _PipeTransport_isClosed, _PipeTransport_pendingMessage, _PipeTransport_dispatch;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipeTransport = void 0;
+/**
+ * Copyright 2018 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.
+ */
+const assert_1 = require("./assert");
+const util_1 = require("./util");
+class PipeTransport {
+    constructor(pipeWrite, pipeRead) {
+        _PipeTransport_instances.add(this);
+        _PipeTransport_pipeWrite.set(this, void 0);
+        _PipeTransport_eventListeners.set(this, void 0);
+        _PipeTransport_isClosed.set(this, false);
+        _PipeTransport_pendingMessage.set(this, '');
+        __classPrivateFieldSet(this, _PipeTransport_pipeWrite, pipeWrite, "f");
+        __classPrivateFieldSet(this, _PipeTransport_eventListeners, [
+            (0, util_1.addEventListener)(pipeRead, 'data', (buffer) => {
+                return __classPrivateFieldGet(this, _PipeTransport_instances, "m", _PipeTransport_dispatch).call(this, buffer);
+            }),
+            (0, util_1.addEventListener)(pipeRead, 'close', () => {
+                if (this.onclose) {
+                    this.onclose.call(null);
+                }
+            }),
+            (0, util_1.addEventListener)(pipeRead, 'error', util_1.debugError),
+            (0, util_1.addEventListener)(pipeWrite, 'error', util_1.debugError),
+        ], "f");
+    }
+    send(message) {
+        (0, assert_1.assert)(!__classPrivateFieldGet(this, _PipeTransport_isClosed, "f"), '`PipeTransport` is closed.');
+        __classPrivateFieldGet(this, _PipeTransport_pipeWrite, "f").write(message);
+        __classPrivateFieldGet(this, _PipeTransport_pipeWrite, "f").write('\0');
+    }
+    close() {
+        __classPrivateFieldSet(this, _PipeTransport_isClosed, true, "f");
+        (0, util_1.removeEventListeners)(__classPrivateFieldGet(this, _PipeTransport_eventListeners, "f"));
+    }
+}
+exports.PipeTransport = PipeTransport;
+_PipeTransport_pipeWrite = new WeakMap(), _PipeTransport_eventListeners = new WeakMap(), _PipeTransport_isClosed = new WeakMap(), _PipeTransport_pendingMessage = new WeakMap(), _PipeTransport_instances = new WeakSet(), _PipeTransport_dispatch = function _PipeTransport_dispatch(buffer) {
+    (0, assert_1.assert)(!__classPrivateFieldGet(this, _PipeTransport_isClosed, "f"), '`PipeTransport` is closed.');
+    let end = buffer.indexOf('\0');
+    if (end === -1) {
+        __classPrivateFieldSet(this, _PipeTransport_pendingMessage, __classPrivateFieldGet(this, _PipeTransport_pendingMessage, "f") + buffer.toString(), "f");
+        return;
+    }
+    const message = __classPrivateFieldGet(this, _PipeTransport_pendingMessage, "f") + buffer.toString(undefined, 0, end);
+    if (this.onmessage) {
+        this.onmessage.call(null, message);
+    }
+    let start = end + 1;
+    end = buffer.indexOf('\0', start);
+    while (end !== -1) {
+        if (this.onmessage) {
+            this.onmessage.call(null, buffer.toString(undefined, start, end));
+        }
+        start = end + 1;
+        end = buffer.indexOf('\0', start);
+    }
+    __classPrivateFieldSet(this, _PipeTransport_pendingMessage, buffer.toString(undefined, start), "f");
+};

package/dist/browser/Product.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ */
+export declare type Product = 'chrome' | 'firefox';

package/dist/browser/Product.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/Puppeteer.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ */
+import { Browser } from './Browser';
+import { BrowserConnectOptions } from './BrowserConnector';
+import { ConnectionTransport } from './ConnectionTransport';
+import { Product } from './Product';
+/**
+ * @public
+ */
+export interface ConnectOptions extends BrowserConnectOptions {
+    browserWSEndpoint?: string;
+    transport?: ConnectionTransport;
+    product?: Product;
+}
+export declare class Puppeteer {
+    protected _changedProduct: boolean;
+    /**
+     * @internal
+     */
+    constructor();
+    connect(options: ConnectOptions): Promise<Browser>;
+}

package/dist/browser/Puppeteer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Puppeteer = void 0;
+const BrowserConnector_1 = require("./BrowserConnector");
+class Puppeteer {
+    /**
+     * @internal
+     */
+    constructor() {
+        this._changedProduct = false;
+        this.connect = this.connect.bind(this);
+    }
+    connect(options) {
+        return (0, BrowserConnector_1._connectToBrowser)(options);
+    }
+}
+exports.Puppeteer = Puppeteer;

package/dist/browser/PuppeteerNode.d.ts

@@ -0,0 +1,92 @@
+/**
+ * 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 { Browser } from './Browser';
+import { BrowserConnectOptions, ConnectToBrowserOptions } from './BrowserConnector';
+import { BrowserFetcher, BrowserFetcherOptions } from './BrowserFetcher';
+import { ProductLauncher } from './Launcher';
+import { BrowserLaunchArgumentOptions, LaunchOptions } from './LaunchOptions';
+import { Product } from './Product';
+interface PuppeteerLaunchOptions extends LaunchOptions, BrowserLaunchArgumentOptions, BrowserConnectOptions {
+    product?: Product;
+    extraPrefsFirefox?: Record<string, unknown>;
+}
+export declare class PuppeteerNode {
+    #private;
+    _preferredRevision: string;
+    constructor(settings: {
+        preferredRevision: string;
+        productName?: Product;
+    });
+    connect(options: ConnectToBrowserOptions & {
+        product: Product;
+    }): Promise<Browser>;
+    get _productName(): Product | undefined;
+    set _productName(name: Product | undefined);
+    /**
+     * Launches puppeteer and launches a browser instance with given arguments
+     * and options when specified.
+     *
+     * @remarks
+     *
+     * @example
+     * You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+     * ```js
+     * const browser = await puppeteer.launch({
+     *   ignoreDefaultArgs: ['--mute-audio']
+     * });
+     * ```
+     *
+     * **NOTE** Puppeteer can also be used to control the Chrome browser,
+     * but it works best with the version of Chromium it is bundled with.
+     * There is no guarantee it will work with any other version.
+     * Use `executablePath` option with extreme caution.
+     * If Google Chrome (rather than Chromium) is preferred, a {@link https://www.google.com/chrome/browser/canary.html | Chrome Canary} or {@link https://www.chromium.org/getting-involved/dev-channel | Dev Channel} build is suggested.
+     * In `puppeteer.launch([options])`, any mention of Chromium also applies to Chrome.
+     * See {@link https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/ | this article} for a description of the differences between Chromium and Chrome. {@link https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md | This article} describes some differences for Linux users.
+     *
+     * @param options - Set of configurable options to set on the browser.
+     * @returns Promise which resolves to browser instance.
+     */
+    launch(options: PuppeteerLaunchOptions): Promise<Browser>;
+    /**
+     * @remarks
+     *
+     * **NOTE** `puppeteer.executablePath()` is affected by the `PUPPETEER_EXECUTABLE_PATH`
+     * and `PUPPETEER_CHROMIUM_REVISION` environment variables.
+     *
+     * @returns A path where Puppeteer expects to find the bundled browser.
+     * The browser binary might not be there if the download was skipped with
+     * the `PUPPETEER_SKIP_DOWNLOAD` environment variable.
+     */
+    executablePath(channel?: string): string;
+    get _launcher(): ProductLauncher;
+    /**
+     * The name of the browser that is under automation (`"chrome"` or `"firefox"`)
+     *
+     * @remarks
+     * The product is set by the `PUPPETEER_PRODUCT` environment variable or the `product`
+     * option in `puppeteer.launch([options])` and defaults to `chrome`.
+     * Firefox support is experimental.
+     */
+    get product(): string;
+    /**
+     * @param options - Set of configurable options to specify the settings
+     * of the BrowserFetcher.
+     * @returns A new BrowserFetcher instance.
+     */
+    createBrowserFetcher(options: BrowserFetcherOptions): BrowserFetcher;
+}
+export {};

package/dist/browser/PuppeteerNode.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _PuppeteerNode_lazyLauncher, _PuppeteerNode_productName;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerNode = void 0;
+const BrowserConnector_1 = require("./BrowserConnector");
+const BrowserFetcher_1 = require("./BrowserFetcher");
+const Launcher_1 = __importDefault(require("./Launcher"));
+const revisions_1 = require("./revisions");
+class PuppeteerNode {
+    constructor(settings) {
+        _PuppeteerNode_lazyLauncher.set(this, void 0);
+        _PuppeteerNode_productName.set(this, void 0);
+        const { preferredRevision, productName } = settings;
+        __classPrivateFieldSet(this, _PuppeteerNode_productName, productName, "f");
+        this._preferredRevision = preferredRevision;
+        this.connect = this.connect.bind(this);
+        this.launch = this.launch.bind(this);
+        this.executablePath = this.executablePath.bind(this);
+        this.createBrowserFetcher = this.createBrowserFetcher.bind(this);
+    }
+    connect(options) {
+        if (options.product) {
+            this._productName = options.product;
+        }
+        return (0, BrowserConnector_1._connectToBrowser)(options);
+    }
+    get _productName() {
+        return __classPrivateFieldGet(this, _PuppeteerNode_productName, "f");
+    }
+    set _productName(name) {
+        __classPrivateFieldSet(this, _PuppeteerNode_productName, name, "f");
+    }
+    /**
+     * Launches puppeteer and launches a browser instance with given arguments
+     * and options when specified.
+     *
+     * @remarks
+     *
+     * @example
+     * You can use `ignoreDefaultArgs` to filter out `--mute-audio` from default arguments:
+     * ```js
+     * const browser = await puppeteer.launch({
+     *   ignoreDefaultArgs: ['--mute-audio']
+     * });
+     * ```
+     *
+     * **NOTE** Puppeteer can also be used to control the Chrome browser,
+     * but it works best with the version of Chromium it is bundled with.
+     * There is no guarantee it will work with any other version.
+     * Use `executablePath` option with extreme caution.
+     * If Google Chrome (rather than Chromium) is preferred, a {@link https://www.google.com/chrome/browser/canary.html | Chrome Canary} or {@link https://www.chromium.org/getting-involved/dev-channel | Dev Channel} build is suggested.
+     * In `puppeteer.launch([options])`, any mention of Chromium also applies to Chrome.
+     * See {@link https://www.howtogeek.com/202825/what%E2%80%99s-the-difference-between-chromium-and-chrome/ | this article} for a description of the differences between Chromium and Chrome. {@link https://chromium.googlesource.com/chromium/src/+/lkgr/docs/chromium_browser_vs_google_chrome.md | This article} describes some differences for Linux users.
+     *
+     * @param options - Set of configurable options to set on the browser.
+     * @returns Promise which resolves to browser instance.
+     */
+    launch(options) {
+        if (options.product) {
+            this._productName = options.product;
+        }
+        return this._launcher.launch(options);
+    }
+    /**
+     * @remarks
+     *
+     * **NOTE** `puppeteer.executablePath()` is affected by the `PUPPETEER_EXECUTABLE_PATH`
+     * and `PUPPETEER_CHROMIUM_REVISION` environment variables.
+     *
+     * @returns A path where Puppeteer expects to find the bundled browser.
+     * The browser binary might not be there if the download was skipped with
+     * the `PUPPETEER_SKIP_DOWNLOAD` environment variable.
+     */
+    executablePath(channel) {
+        return this._launcher.executablePath(channel);
+    }
+    get _launcher() {
+        if (!__classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f") ||
+            __classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f").product !== this._productName) {
+            switch (this._productName) {
+                case 'firefox':
+                    this._preferredRevision = revisions_1.PUPPETEER_REVISIONS.firefox;
+                    break;
+                case 'chrome':
+                default:
+                    this._preferredRevision = revisions_1.PUPPETEER_REVISIONS.chromium;
+            }
+            // eslint-disable-next-line new-cap
+            __classPrivateFieldSet(this, _PuppeteerNode_lazyLauncher, (0, Launcher_1.default)(this._preferredRevision, this._productName), "f");
+        }
+        return __classPrivateFieldGet(this, _PuppeteerNode_lazyLauncher, "f");
+    }
+    /**
+     * The name of the browser that is under automation (`"chrome"` or `"firefox"`)
+     *
+     * @remarks
+     * The product is set by the `PUPPETEER_PRODUCT` environment variable or the `product`
+     * option in `puppeteer.launch([options])` and defaults to `chrome`.
+     * Firefox support is experimental.
+     */
+    get product() {
+        return this._launcher.product;
+    }
+    /**
+     * @param options - Set of configurable options to specify the settings
+     * of the BrowserFetcher.
+     * @returns A new BrowserFetcher instance.
+     */
+    createBrowserFetcher(options) {
+        return new BrowserFetcher_1.BrowserFetcher(options);
+    }
+}
+exports.PuppeteerNode = PuppeteerNode;
+_PuppeteerNode_lazyLauncher = new WeakMap(), _PuppeteerNode_productName = new WeakMap();

package/dist/browser/PuppeteerViewport.d.ts

@@ -0,0 +1,5 @@
+export interface Viewport {
+    width: number;
+    height: number;
+    deviceScaleFactor: number;
+}

package/dist/browser/PuppeteerViewport.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/browser/QueryHandler.d.ts

@@ -0,0 +1,64 @@
+/**
+ * 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 { DOMWorld, WaitForSelectorOptions } from './DOMWorld';
+import { ElementHandle, JSHandle } from './JSHandle';
+/**
+ * @internal
+ */
+export interface InternalQueryHandler {
+    queryOne?: (element: ElementHandle, selector: string) => Promise<ElementHandle | null>;
+    waitFor?: (domWorld: DOMWorld, selector: string, options: WaitForSelectorOptions) => Promise<ElementHandle | null>;
+    queryAll?: (element: ElementHandle, selector: string) => Promise<ElementHandle[]>;
+    queryAllArray?: (element: ElementHandle, selector: string) => Promise<JSHandle<Element[]>>;
+}
+/**
+ * Contains two functions `queryOne` and `queryAll` that can
+ * be {@link Puppeteer.registerCustomQueryHandler | registered}
+ * as alternative querying strategies. The functions `queryOne` and `queryAll`
+ * are executed in the page context.  `queryOne` should take an `Element` and a
+ * selector string as argument and return a single `Element` or `null` if no
+ * element is found. `queryAll` takes the same arguments but should instead
+ * return a `NodeListOf<Element>` or `Array<Element>` with all the elements
+ * that match the given query selector.
+ * @public
+ */
+export interface CustomQueryHandler {
+    queryOne?: (element: Element | Document, selector: string) => Element | null;
+    queryAll?: (element: Element | Document, selector: string) => Element[] | NodeListOf<Element>;
+}
+/**
+ * @internal
+ */
+export declare function _registerCustomQueryHandler(name: string, handler: CustomQueryHandler): void;
+/**
+ * @internal
+ */
+export declare function _unregisterCustomQueryHandler(name: string): void;
+/**
+ * @internal
+ */
+export declare function _customQueryHandlerNames(): string[];
+/**
+ * @internal
+ */
+export declare function _clearCustomQueryHandlers(): void;
+/**
+ * @internal
+ */
+export declare function _getQueryHandlerAndSelector(selector: string): {
+    updatedSelector: string;
+    queryHandler: InternalQueryHandler;
+};

package/dist/browser/QueryHandler.js

@@ -0,0 +1,183 @@
+"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 });
+exports._getQueryHandlerAndSelector = exports._clearCustomQueryHandlers = exports._customQueryHandlerNames = exports._unregisterCustomQueryHandler = exports._registerCustomQueryHandler = void 0;
+const AriaQueryHandler_1 = require("./AriaQueryHandler");
+function makeQueryHandler(handler) {
+    const internalHandler = {};
+    if (handler.queryOne) {
+        const { queryOne } = handler;
+        internalHandler.queryOne = async (element, selector) => {
+            const jsHandle = await element.evaluateHandle(queryOne, selector);
+            const elementHandle = jsHandle.asElement();
+            if (elementHandle) {
+                return elementHandle;
+            }
+            await jsHandle.dispose();
+            return null;
+        };
+        internalHandler.waitFor = (domWorld, selector, options) => {
+            return domWorld._waitForSelectorInPage(queryOne, selector, options);
+        };
+    }
+    if (handler.queryAll) {
+        const { queryAll } = handler;
+        internalHandler.queryAll = async (element, selector) => {
+            const jsHandle = await element.evaluateHandle(queryAll, selector);
+            const properties = await jsHandle.getProperties();
+            await jsHandle.dispose();
+            const result = [];
+            for (const property of properties.values()) {
+                const elementHandle = property.asElement();
+                if (elementHandle) {
+                    result.push(elementHandle);
+                }
+            }
+            return result;
+        };
+        internalHandler.queryAllArray = async (element, selector) => {
+            const resultHandle = await element.evaluateHandle(queryAll, selector);
+            const arrayHandle = await resultHandle.evaluateHandle((res) => {
+                return Array.from(res);
+            });
+            return arrayHandle;
+        };
+    }
+    return internalHandler;
+}
+const _defaultHandler = makeQueryHandler({
+    queryOne: (element, selector) => {
+        return element.querySelector(selector);
+    },
+    queryAll: (element, selector) => {
+        return element.querySelectorAll(selector);
+    },
+});
+const pierceHandler = makeQueryHandler({
+    queryOne: (element, selector) => {
+        let found = null;
+        const search = (root) => {
+            const iter = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+            do {
+                const currentNode = iter.currentNode;
+                if (currentNode.shadowRoot) {
+                    search(currentNode.shadowRoot);
+                }
+                if (currentNode instanceof ShadowRoot) {
+                    continue;
+                }
+                if (currentNode !== root && !found && currentNode.matches(selector)) {
+                    found = currentNode;
+                }
+            } while (!found && iter.nextNode());
+        };
+        if (element instanceof Document) {
+            element = element.documentElement;
+        }
+        search(element);
+        return found;
+    },
+    queryAll: (element, selector) => {
+        const result = [];
+        const collect = (root) => {
+            const iter = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT);
+            do {
+                const currentNode = iter.currentNode;
+                if (currentNode.shadowRoot) {
+                    collect(currentNode.shadowRoot);
+                }
+                if (currentNode instanceof ShadowRoot) {
+                    continue;
+                }
+                if (currentNode !== root && currentNode.matches(selector)) {
+                    result.push(currentNode);
+                }
+            } while (iter.nextNode());
+        };
+        if (element instanceof Document) {
+            element = element.documentElement;
+        }
+        collect(element);
+        return result;
+    },
+});
+const builtInHandlers = new Map([
+    ['aria', AriaQueryHandler_1._ariaHandler],
+    ['pierce', pierceHandler],
+]);
+const queryHandlers = new Map(builtInHandlers);
+/**
+ * @internal
+ */
+function _registerCustomQueryHandler(name, handler) {
+    if (queryHandlers.get(name)) {
+        throw new Error(`A custom query handler named "${name}" already exists`);
+    }
+    const isValidName = /^[a-zA-Z]+$/.test(name);
+    if (!isValidName) {
+        throw new Error(`Custom query handler names may only contain [a-zA-Z]`);
+    }
+    const internalHandler = makeQueryHandler(handler);
+    queryHandlers.set(name, internalHandler);
+}
+exports._registerCustomQueryHandler = _registerCustomQueryHandler;
+/**
+ * @internal
+ */
+function _unregisterCustomQueryHandler(name) {
+    if (queryHandlers.has(name) && !builtInHandlers.has(name)) {
+        queryHandlers.delete(name);
+    }
+}
+exports._unregisterCustomQueryHandler = _unregisterCustomQueryHandler;
+/**
+ * @internal
+ */
+function _customQueryHandlerNames() {
+    return [...queryHandlers.keys()].filter((name) => {
+        return !builtInHandlers.has(name);
+    });
+}
+exports._customQueryHandlerNames = _customQueryHandlerNames;
+/**
+ * @internal
+ */
+function _clearCustomQueryHandlers() {
+    _customQueryHandlerNames().forEach(_unregisterCustomQueryHandler);
+}
+exports._clearCustomQueryHandlers = _clearCustomQueryHandlers;
+/**
+ * @internal
+ */
+function _getQueryHandlerAndSelector(selector) {
+    const hasCustomQueryHandler = /^[a-zA-Z]+\//.test(selector);
+    if (!hasCustomQueryHandler) {
+        return { updatedSelector: selector, queryHandler: _defaultHandler };
+    }
+    const index = selector.indexOf('/');
+    const name = selector.slice(0, index);
+    const updatedSelector = selector.slice(index + 1);
+    const queryHandler = queryHandlers.get(name);
+    if (!queryHandler) {
+        throw new Error(`Query set to use "${name}", but no query handler of that name was found`);
+    }
+    return {
+        updatedSelector,
+        queryHandler,
+    };
+}
+exports._getQueryHandlerAndSelector = _getQueryHandlerAndSelector;