conductor-oss 0.3.3 → 0.4.0

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/PSelectorParser.js

@@ -0,0 +1,100 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { tokenize, TOKENS, stringify, } from '../../third_party/parsel-js/parsel-js.js';
+TOKENS['nesting'] = /&/g;
+TOKENS['combinator'] = /\s*(>>>>?|[\s>+~])\s*/g;
+const ESCAPE_REGEXP = /\\[\s\S]/g;
+const unquote = (text) => {
+    if (text.length <= 1) {
+        return text;
+    }
+    if ((text[0] === '"' || text[0] === "'") && text.endsWith(text[0])) {
+        text = text.slice(1, -1);
+    }
+    return text.replace(ESCAPE_REGEXP, match => {
+        return match[1];
+    });
+};
+/**
+ * @internal
+ */
+export function parsePSelectors(selector) {
+    let isPureCSS = true;
+    let hasAria = false;
+    let hasPseudoClasses = false;
+    const tokens = tokenize(selector);
+    if (tokens.length === 0) {
+        return [[], isPureCSS, hasPseudoClasses, false];
+    }
+    let compoundSelector = [];
+    let complexSelector = [compoundSelector];
+    const selectors = [complexSelector];
+    const storage = [];
+    for (const token of tokens) {
+        switch (token.type) {
+            case 'combinator':
+                switch (token.content) {
+                    case ">>>" /* PCombinator.Descendent */:
+                        isPureCSS = false;
+                        if (storage.length) {
+                            compoundSelector.push(stringify(storage));
+                            storage.splice(0);
+                        }
+                        compoundSelector = [];
+                        complexSelector.push(">>>" /* PCombinator.Descendent */);
+                        complexSelector.push(compoundSelector);
+                        continue;
+                    case ">>>>" /* PCombinator.Child */:
+                        isPureCSS = false;
+                        if (storage.length) {
+                            compoundSelector.push(stringify(storage));
+                            storage.splice(0);
+                        }
+                        compoundSelector = [];
+                        complexSelector.push(">>>>" /* PCombinator.Child */);
+                        complexSelector.push(compoundSelector);
+                        continue;
+                }
+                break;
+            case 'pseudo-element':
+                if (!token.name.startsWith('-p-')) {
+                    break;
+                }
+                isPureCSS = false;
+                if (storage.length) {
+                    compoundSelector.push(stringify(storage));
+                    storage.splice(0);
+                }
+                const name = token.name.slice(3);
+                if (name === 'aria') {
+                    hasAria = true;
+                }
+                compoundSelector.push({
+                    name,
+                    value: unquote(token.argument ?? ''),
+                });
+                continue;
+            case 'pseudo-class':
+                hasPseudoClasses = true;
+                break;
+            case 'comma':
+                if (storage.length) {
+                    compoundSelector.push(stringify(storage));
+                    storage.splice(0);
+                }
+                compoundSelector = [];
+                complexSelector = [compoundSelector];
+                selectors.push(complexSelector);
+                continue;
+        }
+        storage.push(token);
+    }
+    if (storage.length) {
+        compoundSelector.push(stringify(storage));
+    }
+    return [selectors, isPureCSS, hasPseudoClasses, hasAria];
+}
+//# sourceMappingURL=PSelectorParser.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/PierceQueryHandler.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { QueryHandler } from './QueryHandler.js';
+/**
+ * @internal
+ */
+export class PierceQueryHandler extends QueryHandler {
+    static querySelector = (element, selector, { pierceQuerySelector }) => {
+        return pierceQuerySelector(element, selector);
+    };
+    static querySelectorAll = (element, selector, { pierceQuerySelectorAll }) => {
+        return pierceQuerySelectorAll(element, selector);
+    };
+}
+//# sourceMappingURL=PierceQueryHandler.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/Puppeteer.js

@@ -0,0 +1,98 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { _connectToBrowser } from './BrowserConnector.js';
+import { customQueryHandlers, } from './CustomQueryHandler.js';
+/**
+ * The main Puppeteer class.
+ *
+ * IMPORTANT: if you are using Puppeteer in a Node environment, you will get an
+ * instance of {@link PuppeteerNode} when you import or require `puppeteer`.
+ * That class extends `Puppeteer`, so has all the methods documented below as
+ * well as all that are defined on {@link PuppeteerNode}.
+ *
+ * @public
+ */
+export class Puppeteer {
+    /**
+     * Operations for {@link CustomQueryHandler | custom query handlers}. See
+     * {@link CustomQueryHandlerRegistry}.
+     *
+     * @internal
+     */
+    static customQueryHandlers = customQueryHandlers;
+    /**
+     * Registers a {@link CustomQueryHandler | custom query handler}.
+     *
+     * @remarks
+     * After registration, the handler can be used everywhere where a selector is
+     * expected by prepending the selection string with `<name>/`. The name is only
+     * allowed to consist of lower- and upper case latin letters.
+     *
+     * @example
+     *
+     * ```
+     * import {Puppeteer}, puppeteer from 'puppeteer';
+     *
+     * Puppeteer.registerCustomQueryHandler('text', { … });
+     * const aHandle = await page.$('text/…');
+     * ```
+     *
+     * @param name - The name that the custom query handler will be registered
+     * under.
+     * @param queryHandler - The {@link CustomQueryHandler | custom query handler}
+     * to register.
+     *
+     * @public
+     */
+    static registerCustomQueryHandler(name, queryHandler) {
+        return this.customQueryHandlers.register(name, queryHandler);
+    }
+    /**
+     * Unregisters a custom query handler for a given name.
+     */
+    static unregisterCustomQueryHandler(name) {
+        return this.customQueryHandlers.unregister(name);
+    }
+    /**
+     * Gets the names of all custom query handlers.
+     */
+    static customQueryHandlerNames() {
+        return this.customQueryHandlers.names();
+    }
+    /**
+     * Unregisters all custom query handlers.
+     */
+    static clearCustomQueryHandlers() {
+        return this.customQueryHandlers.clear();
+    }
+    /**
+     * @internal
+     */
+    _isPuppeteerCore;
+    /**
+     * @internal
+     */
+    _changedBrowsers = false;
+    /**
+     * @internal
+     */
+    constructor(settings) {
+        this._isPuppeteerCore = settings.isPuppeteerCore;
+        this.connect = this.connect.bind(this);
+    }
+    /**
+     * This method attaches Puppeteer to an existing browser instance.
+     *
+     * @remarks
+     *
+     * @param options - Set of configurable options to set on the browser.
+     * @returns Promise which resolves to browser instance.
+     */
+    connect(options) {
+        return _connectToBrowser(options);
+    }
+}
+//# sourceMappingURL=Puppeteer.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/QueryHandler.js

@@ -0,0 +1,225 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { _isElementHandle } from '../api/ElementHandleSymbol.js';
+import { isErrorLike } from '../util/ErrorLike.js';
+import { interpolateFunction, stringifyFunction } from '../util/Function.js';
+import { TimeoutError } from './Errors.js';
+import { transposeIterableHandle } from './HandleIterator.js';
+import { LazyArg } from './LazyArg.js';
+/**
+ * @internal
+ */
+export class QueryHandler {
+    // Either one of these may be implemented, but at least one must be.
+    static querySelectorAll;
+    static querySelector;
+    static get _querySelector() {
+        if (this.querySelector) {
+            return this.querySelector;
+        }
+        if (!this.querySelectorAll) {
+            throw new Error('Cannot create default `querySelector`.');
+        }
+        return (this.querySelector = interpolateFunction(async (node, selector, PuppeteerUtil) => {
+            const querySelectorAll = PLACEHOLDER('querySelectorAll');
+            const results = querySelectorAll(node, selector, PuppeteerUtil);
+            for await (const result of results) {
+                return result;
+            }
+            return null;
+        }, {
+            querySelectorAll: stringifyFunction(this.querySelectorAll),
+        }));
+    }
+    static get _querySelectorAll() {
+        if (this.querySelectorAll) {
+            return this.querySelectorAll;
+        }
+        if (!this.querySelector) {
+            throw new Error('Cannot create default `querySelectorAll`.');
+        }
+        return (this.querySelectorAll = interpolateFunction(async function* (node, selector, PuppeteerUtil) {
+            const querySelector = PLACEHOLDER('querySelector');
+            const result = await querySelector(node, selector, PuppeteerUtil);
+            if (result) {
+                yield result;
+            }
+        }, {
+            querySelector: stringifyFunction(this.querySelector),
+        }));
+    }
+    /**
+     * Queries for multiple nodes given a selector and {@link ElementHandle}.
+     *
+     * Akin to {@link https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelectorAll | Document.querySelectorAll()}.
+     */
+    static async *queryAll(element, selector) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const handle = __addDisposableResource(env_1, await element.evaluateHandle(this._querySelectorAll, selector, LazyArg.create(context => {
+                return context.puppeteerUtil;
+            })), false);
+            yield* transposeIterableHandle(handle);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    /**
+     * Queries for a single node given a selector and {@link ElementHandle}.
+     *
+     * Akin to {@link https://developer.mozilla.org/en-US/docs/Web/API/Document/querySelector}.
+     */
+    static async queryOne(element, selector) {
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const result = __addDisposableResource(env_2, await element.evaluateHandle(this._querySelector, selector, LazyArg.create(context => {
+                return context.puppeteerUtil;
+            })), false);
+            if (!(_isElementHandle in result)) {
+                return null;
+            }
+            return result.move();
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            __disposeResources(env_2);
+        }
+    }
+    /**
+     * Waits until a single node appears for a given selector and
+     * {@link ElementHandle}.
+     *
+     * This will always query the handle in the Puppeteer world and migrate the
+     * result to the main world.
+     */
+    static async waitFor(elementOrFrame, selector, options) {
+        const env_3 = { stack: [], error: void 0, hasError: false };
+        try {
+            let frame;
+            const element = __addDisposableResource(env_3, await (async () => {
+                if (!(_isElementHandle in elementOrFrame)) {
+                    frame = elementOrFrame;
+                    return;
+                }
+                frame = elementOrFrame.frame;
+                return await frame.isolatedRealm().adoptHandle(elementOrFrame);
+            })(), false);
+            const { visible = false, hidden = false, timeout, signal } = options;
+            const polling = visible || hidden ? "raf" /* PollingOptions.RAF */ : options.polling;
+            try {
+                const env_4 = { stack: [], error: void 0, hasError: false };
+                try {
+                    signal?.throwIfAborted();
+                    const handle = __addDisposableResource(env_4, await frame.isolatedRealm().waitForFunction(async (PuppeteerUtil, query, selector, root, visible) => {
+                        const querySelector = PuppeteerUtil.createFunction(query);
+                        const node = await querySelector(root ?? document, selector, PuppeteerUtil);
+                        return PuppeteerUtil.checkVisibility(node, visible);
+                    }, {
+                        polling,
+                        root: element,
+                        timeout,
+                        signal,
+                    }, LazyArg.create(context => {
+                        return context.puppeteerUtil;
+                    }), stringifyFunction(this._querySelector), selector, element, visible ? true : hidden ? false : undefined), false);
+                    if (signal?.aborted) {
+                        throw signal.reason;
+                    }
+                    if (!(_isElementHandle in handle)) {
+                        return null;
+                    }
+                    return await frame.mainRealm().transferHandle(handle);
+                }
+                catch (e_3) {
+                    env_4.error = e_3;
+                    env_4.hasError = true;
+                }
+                finally {
+                    __disposeResources(env_4);
+                }
+            }
+            catch (error) {
+                if (!isErrorLike(error)) {
+                    throw error;
+                }
+                if (error.name === 'AbortError') {
+                    throw error;
+                }
+                const waitForSelectorError = new (error instanceof TimeoutError ? TimeoutError : Error)(`Waiting for selector \`${selector}\` failed`);
+                waitForSelectorError.cause = error;
+                throw waitForSelectorError;
+            }
+        }
+        catch (e_4) {
+            env_3.error = e_4;
+            env_3.hasError = true;
+        }
+        finally {
+            __disposeResources(env_3);
+        }
+    }
+}
+//# sourceMappingURL=QueryHandler.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/ScriptInjector.js

@@ -0,0 +1,51 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { source as injectedSource } from '../generated/injected.js';
+/**
+ * @internal
+ */
+export class ScriptInjector {
+    #updated = false;
+    #amendments = new Set();
+    // Appends a statement of the form `(PuppeteerUtil) => {...}`.
+    append(statement) {
+        this.#update(() => {
+            this.#amendments.add(statement);
+        });
+    }
+    pop(statement) {
+        this.#update(() => {
+            this.#amendments.delete(statement);
+        });
+    }
+    inject(inject, force = false) {
+        if (this.#updated || force) {
+            inject(this.#get());
+        }
+        this.#updated = false;
+    }
+    #update(callback) {
+        callback();
+        this.#updated = true;
+    }
+    #get() {
+        return `(() => {
+      const module = {};
+      ${injectedSource}
+      ${[...this.#amendments]
+            .map(statement => {
+            return `(${statement})(module.exports.default);`;
+        })
+            .join('')}
+      return module.exports.default;
+    })()`;
+    }
+}
+/**
+ * @internal
+ */
+export const scriptInjector = new ScriptInjector();
+//# sourceMappingURL=ScriptInjector.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/SecurityDetails.js

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The SecurityDetails class represents the security details of a
+ * response that was received over a secure connection.
+ *
+ * @public
+ */
+export class SecurityDetails {
+    #subjectName;
+    #issuer;
+    #validFrom;
+    #validTo;
+    #protocol;
+    #sanList;
+    /**
+     * @internal
+     */
+    constructor(securityPayload) {
+        this.#subjectName = securityPayload.subjectName;
+        this.#issuer = securityPayload.issuer;
+        this.#validFrom = securityPayload.validFrom;
+        this.#validTo = securityPayload.validTo;
+        this.#protocol = securityPayload.protocol;
+        this.#sanList = securityPayload.sanList;
+    }
+    /**
+     * The name of the issuer of the certificate.
+     */
+    issuer() {
+        return this.#issuer;
+    }
+    /**
+     * {@link https://en.wikipedia.org/wiki/Unix_time | Unix timestamp}
+     * marking the start of the certificate's validity.
+     */
+    validFrom() {
+        return this.#validFrom;
+    }
+    /**
+     * {@link https://en.wikipedia.org/wiki/Unix_time | Unix timestamp}
+     * marking the end of the certificate's validity.
+     */
+    validTo() {
+        return this.#validTo;
+    }
+    /**
+     * The security protocol being used, e.g. "TLS 1.2".
+     */
+    protocol() {
+        return this.#protocol;
+    }
+    /**
+     * The name of the subject to which the certificate was issued.
+     */
+    subjectName() {
+        return this.#subjectName;
+    }
+    /**
+     * The list of {@link https://en.wikipedia.org/wiki/Subject_Alternative_Name | subject alternative names (SANs)} of the certificate.
+     */
+    subjectAlternativeNames() {
+        return this.#sanList;
+    }
+}
+//# sourceMappingURL=SecurityDetails.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/TaskQueue.js

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @internal
+ */
+export class TaskQueue {
+    #chain;
+    constructor() {
+        this.#chain = Promise.resolve();
+    }
+    postTask(task) {
+        const result = this.#chain.then(task);
+        this.#chain = result.then(() => {
+            return undefined;
+        }, () => {
+            return undefined;
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=TaskQueue.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/TextQueryHandler.js

@@ -0,0 +1,15 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { QueryHandler } from './QueryHandler.js';
+/**
+ * @internal
+ */
+export class TextQueryHandler extends QueryHandler {
+    static querySelectorAll = (element, selector, { textQuerySelectorAll }) => {
+        return textQuerySelectorAll(element, selector);
+    };
+}
+//# sourceMappingURL=TextQueryHandler.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/common/TimeoutSettings.js

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2019 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const DEFAULT_TIMEOUT = 30000;
+/**
+ * @internal
+ */
+export class TimeoutSettings {
+    #defaultTimeout;
+    #defaultNavigationTimeout;
+    constructor() {
+        this.#defaultTimeout = null;
+        this.#defaultNavigationTimeout = null;
+    }
+    setDefaultTimeout(timeout) {
+        this.#defaultTimeout = timeout;
+    }
+    setDefaultNavigationTimeout(timeout) {
+        this.#defaultNavigationTimeout = timeout;
+    }
+    navigationTimeout() {
+        if (this.#defaultNavigationTimeout !== null) {
+            return this.#defaultNavigationTimeout;
+        }
+        if (this.#defaultTimeout !== null) {
+            return this.#defaultTimeout;
+        }
+        return DEFAULT_TIMEOUT;
+    }
+    timeout() {
+        if (this.#defaultTimeout !== null) {
+            return this.#defaultTimeout;
+        }
+        return DEFAULT_TIMEOUT;
+    }
+}
+//# sourceMappingURL=TimeoutSettings.js.map