@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/dist/browser/browser.js

@@ -0,0 +1,372 @@
+import { spawn } from "node:child_process";
+import { setTimeout as sleep } from "node:timers/promises";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { findBrowser } from "./browser-finder.js";
+import path from "node:path";
+import { BiDiConnector } from "../transport/bidi-connection.js";
+import Page from "./page.js";
+import { BrowserContext } from "./browser-context.js";
+import { validateEmulation } from "./emulation.js";
+import { prepareDownloadsDir, removeIfEmpty } from "./downloads-dir.js";
+import logger from "../logger/index.js";
+import { browsersDir, projectDir, readConfig } from "../config/config.js";
+/**
+ * Sent with session.new. With "ignore" the browser leaves a JavaScript dialog open and reports it
+ * (`browsingContext.userPromptOpened`), so the framework decides how to answer instead of the browser.
+ */
+export const SESSION_CAPABILITIES = {
+    alwaysMatch: { unhandledPromptBehavior: { default: "ignore" } },
+};
+/** Time (ms) to wait for Firefox to answer browser.close before killing the process */
+const BROWSER_CLOSE_GRACE = 2000;
+const browserProfilePath = (browserName) => path.join(browsersDir(), "profiles", browserName, "user.js");
+const baseBrowserLaunchFlags = {
+    // chrome: [],
+    firefox: ["--no-sandbox", "--no-remote"],
+};
+/** Read when a browser launches, since the profile folder depends on the active project */
+const defaultLaunchOptions = (browserName) => ({
+    port: 9222,
+    profileDir: path.dirname(browserProfilePath(browserName)),
+    headless: true,
+});
+const regexPrefix = {
+    firefox: /WebDriver\sBiDi\slistening\son\s/,
+    // chrome: /DevTools\slistening\son/,
+};
+export const browserLaunchFlag = (browserName, launchOptions) => {
+    const defLaunchOpts = defaultLaunchOptions(browserName);
+    const port = launchOptions.port || defLaunchOpts.port;
+    const profileDir = launchOptions.profileDir || defLaunchOpts.profileDir;
+    const headless = launchOptions.headless ?? defLaunchOpts.headless;
+    const baseLaunchFlags = [...baseBrowserLaunchFlags[browserName]];
+    if (headless) {
+        baseLaunchFlags.push("--headless");
+    }
+    baseLaunchFlags.push(`--remote-debugging-port=${port}`);
+    switch (browserName) {
+        // case "chrome":
+        //   baseLaunchFlags.push(`--user-data-dir=${profileDir}`);
+        // break;
+        case "firefox":
+            baseLaunchFlags.push("--profile", profileDir);
+            // The home page (about:home) is privileged: BiDi refuses commands such as setViewport on it
+            baseLaunchFlags.push("about:blank");
+            break;
+    }
+    logger.verbose("Launch flags for browser %s: ", browserName, {
+        baseLaunchFlags,
+    });
+    return baseLaunchFlags;
+};
+/**
+ * Stops what a failed launch started. A browser left running holds the profile (the next launch
+ * fails with "already open") and keeps the test process alive.
+ */
+export function abandonLaunch(browserProc, biDiConnector) {
+    biDiConnector?.kill();
+    browserProc.kill();
+}
+// On macOS a spawned browser is attributed to the terminal, which is denied access to
+// ~/Library/Application Support/Firefox (profiles.ini). Point Firefox at a local app data dir instead.
+const browserAppDataPath = (browserName) => path.join(browsersDir(), "app-data", browserName);
+const browserLaunchEnv = (browserName) => {
+    const appDataPath = browserAppDataPath(browserName);
+    mkdirSync(appDataPath, { recursive: true });
+    logger.debug("Using app data dir for %s: %s", browserName, appDataPath);
+    switch (browserName) {
+        case "firefox":
+            return { MOZ_APP_DATA: appDataPath };
+    }
+};
+const browserProfiles = {
+    // chrome: "",
+    firefox: `
+    user_pref("devtools.debugger.remote-enabled", true);
+    user_pref("devtools.debugger.prompt-connection", false);
+    user_pref("devtools.chrome.enabled", true);
+    // The home page (about:home) is privileged: BiDi refuses commands such as setViewport on it
+    user_pref("browser.startup.page", 0);
+    user_pref("browser.startup.homepage", "about:blank");
+    user_pref("browser.newtabpage.enabled", false);
+  `,
+};
+// Firefox logs "WebDriver BiDi listening on ws://<host>:<port>" without the endpoint path
+const browserWsPath = {
+    firefox: "/session",
+};
+const browserWsRegex = {
+    firefox: /ws:\/\/(\d){1,3}.(\d){1,3}.(\d){1,3}.(\d){1,3}:(\d){4}/g,
+    // chrome:
+    //   /ws:\/\/(\d){1,3}.(\d){1,3}.(\d){1,3}.(\d){1,3}:(\d){4}\/devtools\/browser\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/g,
+};
+export class Browser {
+    constructor({ browserProc, biDiConnector, downloadsDir, }) {
+        this.userContexts = new Map();
+        this.browserProc = browserProc;
+        this.biDiConnector = biDiConnector;
+        this.downloadsDir = downloadsDir;
+        this.host = {
+            connector: biDiConnector,
+            newPage: (options) => this.newPage(options),
+            forget: (context) => void this.userContexts.delete(context.id),
+        };
+        this.defaultContext = new BrowserContext(this.host, "default", true);
+    }
+    /** Resolves when the browser process has exited, whether `close()` or a person closed it */
+    get exited() {
+        this.exitedPromise ??= new Promise((resolve) => {
+            if (this.browserProc.exitCode !== null || this.browserProc.signalCode)
+                return resolve();
+            this.browserProc.once("exit", () => resolve());
+        });
+        return this.exitedPromise;
+    }
+    static async launch(browserName, launchOptions = defaultLaunchOptions(browserName), 
+    /** Aborting kills the browser process and rejects the launch */
+    signal) {
+        signal?.throwIfAborted();
+        logger.verbose("Trying to launch browser %s", browserName);
+        const browserLocation = findBrowser(browserName);
+        logger.debug("Found browser install location at: %s", browserLocation);
+        ensureBrowserProfile(browserName);
+        logger.verbose("Trying to spawn %s process", browserName);
+        const browserProc = spawn(browserLocation, browserLaunchFlag(browserName, launchOptions), { env: { ...process.env, ...browserLaunchEnv(browserName) } });
+        return new Promise((resolve, reject) => {
+            const onUnexpectedClose = (code) => {
+                reject(new Error(`Browser process exited unexpectedly with code ${code}`));
+            };
+            browserProc.on("close", onUnexpectedClose);
+            const onAbort = () => {
+                logger.verbose("Launch of %s aborted, killing process", browserName);
+                browserProc.kill();
+                reject(signal?.reason);
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            browserProc.stdout.on("data", (data) => {
+                logger.debug(`${browserName} stdout: ${data}`);
+                if (String(data).match(/!!!\scould\snot\sstart\sserver\son\sport\s(\d){4}/g)) {
+                    browserProc.kill();
+                    reject(`PORT ${launchOptions.port} is already in use!`);
+                }
+            });
+            browserProc.stderr.on("data", async (data) => {
+                logger.debug(`${browserName} stderr: ${data}`);
+                const urlMatch = String(data).match(browserWsRegex[browserName]);
+                logger.debug("Browser announced its endpoint", { urlMatch });
+                if (!Array.isArray(urlMatch) || urlMatch.length === 0) {
+                    return;
+                }
+                // Killing the process mid-handshake rejects pending BiDi calls; surface that via reject
+                // instead of an unhandled rejection from this async listener
+                let biDiConnector;
+                try {
+                    let url = urlMatch[0] + browserWsPath[browserName];
+                    logger.verbose("Websocket URL match: %s", url);
+                    biDiConnector = await BiDiConnector.connect(url, {
+                        commandTimeout: await readCommandTimeout(),
+                    });
+                    logger.verbose("Starting new session");
+                    const status = await biDiConnector.send("session.status", {});
+                    logger.verbose("Session status", status);
+                    await biDiConnector.send("session.new", {
+                        capabilities: SESSION_CAPABILITIES,
+                    });
+                    logger.verbose("Session started successfully");
+                    const downloadsDir = await prepareDownloadsDir(biDiConnector, path.resolve(projectDir(), (await readOptionalConfig("downloadsDir")) ?? "result/downloads"));
+                    const browser = new Browser({
+                        browserProc,
+                        biDiConnector,
+                        downloadsDir,
+                    });
+                    logger.verbose("Requesting current browser tree");
+                    const browserTree = await biDiConnector.send("browsingContext.getTree", {});
+                    logger.verbose("Received current browser tree");
+                    logger.debug("Browser tree: ", { browserTree });
+                    const pageContext = browserTree.contexts[0];
+                    let page = undefined;
+                    if (pageContext) {
+                        page = new Page(biDiConnector, pageContext.context);
+                        browser.defaultContext.register(page);
+                    }
+                    else {
+                        page = await browser.newPage({ type: "tab" });
+                    }
+                    await page.applyDefaultViewport();
+                    // Requests made before tracking starts are invisible to it, and a dialog nobody watches would hang the page
+                    await page.startNetworkTracking();
+                    await page.startDialogHandling();
+                    await page.startLogging();
+                    await page.startDownloadTracking();
+                    await page.startFileChooserTracking();
+                    browserProc.off("close", onUnexpectedClose);
+                    signal?.removeEventListener("abort", onAbort);
+                    resolve({
+                        browser,
+                        page,
+                    });
+                }
+                catch (err) {
+                    browserProc.off("close", onUnexpectedClose);
+                    signal?.removeEventListener("abort", onAbort);
+                    abandonLaunch(browserProc, biDiConnector);
+                    reject(err);
+                }
+            });
+        });
+    }
+    /** Closes the browser via BiDi browser.close, then makes sure the process has exited */
+    async close() {
+        if (this.browserProc.exitCode !== null || this.browserProc.signalCode) {
+            this.biDiConnector.kill();
+            removeIfEmpty(this.downloadsDir);
+            return;
+        }
+        const exited = new Promise((resolve) => this.browserProc.once("exit", resolve));
+        // User contexts outlive the browser in its profile unless they are removed
+        await Promise.allSettled([...this.userContexts.values()].map((context) => context.close()));
+        try {
+            // Firefox may exit without answering; a lost reply must not hold up teardown
+            await Promise.race([
+                this.biDiConnector.send("browser.close", {}),
+                sleep(BROWSER_CLOSE_GRACE, undefined, { ref: false }),
+            ]);
+        }
+        catch {
+            // browser may already be shutting down
+        }
+        this.biDiConnector.kill();
+        this.browserProc.kill();
+        await exited;
+        // A folder nothing was downloaded into would only pile up
+        removeIfEmpty(this.downloadsDir);
+    }
+    /** Alias of close() */
+    async kill() {
+        await this.close();
+    }
+    async newPage({ type, background, userContext, }) {
+        const createBrowserContext = await this.biDiConnector.send("browsingContext.create", {
+            type,
+            background,
+            userContext,
+        });
+        logger.debug("Created browsing context", { createBrowserContext });
+        const page = new Page(this.biDiConnector, createBrowserContext.context);
+        this.contextFor(userContext).register(page);
+        await page.applyDefaultViewport();
+        await page.startNetworkTracking();
+        await page.startDialogHandling();
+        await page.startLogging();
+        await page.startDownloadTracking();
+        await page.startFileChooserTracking();
+        return page;
+    }
+    /**
+     * Creates an isolated context: its own cookies, storage and cache. `browser.close()` removes the contexts
+     * that are still open, as Firefox would otherwise keep them in its profile.
+     * @example
+     *  const alice = await browser.newContext();
+     *  const page = await alice.newPage();
+     */
+    async newContext(options = {}) {
+        const { acceptInsecureCerts, unhandledPromptBehavior, ...emulation } = options;
+        // A wrong value must not leave a context behind, so it is refused before one is created
+        validateEmulation(emulation);
+        const { userContext } = await this.biDiConnector.send("browser.createUserContext", {
+            ...(acceptInsecureCerts !== undefined && { acceptInsecureCerts }),
+            ...(unhandledPromptBehavior && { unhandledPromptBehavior }),
+        });
+        const context = new BrowserContext(this.host, userContext, false);
+        this.userContexts.set(userContext, context);
+        if (Object.keys(emulation).length > 0) {
+            try {
+                await context.emulate(emulation);
+            }
+            catch (err) {
+                // Firefox keeps a context in its profile until it is removed
+                await context.close().catch((closeErr) => logger.debug("Could not remove a context whose emulation failed", {
+                    closeErr,
+                }));
+                throw err;
+            }
+        }
+        return context;
+    }
+    /** The default context, then the contexts this browser created that are still open */
+    contexts() {
+        return [this.defaultContext, ...this.userContexts.values()];
+    }
+    contextFor(userContext) {
+        if (userContext === undefined || userContext === "default")
+            return this.defaultContext;
+        return this.userContexts.get(userContext) ?? this.adopt(userContext);
+    }
+    /** A user context this browser did not create (Firefox keeps them in its profile): usable, never closed by `close()` */
+    adopt(userContext) {
+        const context = new BrowserContext(this.host, userContext, false);
+        this.userContexts.set(userContext, context);
+        return context;
+    }
+    async getCookie(filter, partition) {
+        return await this.biDiConnector.send("storage.getCookies", {
+            filter,
+            partition,
+        });
+    }
+    async setCookie(cookie, partition) {
+        return await this.biDiConnector.send("storage.setCookie", {
+            partition,
+            cookie,
+        });
+    }
+}
+/** A config value, or undefined when it is not set or the config cannot be read */
+async function readOptionalConfig(key) {
+    try {
+        return await readConfig(key);
+    }
+    catch (err) {
+        logger.debug("Could not read %s from config, using the default", key, {
+            err,
+        });
+        return undefined;
+    }
+}
+/** The configured BiDi command timeout; a missing or unreadable config falls back to the connector default */
+async function readCommandTimeout() {
+    try {
+        return (await readConfig("bidi"))?.commandTimeout;
+    }
+    catch (err) {
+        logger.debug("Could not read bidi config, using defaults", { err });
+        return undefined;
+    }
+}
+/** Writes the browser's user.js unless it already holds the current prefs; an outdated one is replaced */
+export function ensureBrowserProfile(browserName, profilePath = browserProfilePath(browserName)) {
+    logger.verbose("Checking browser profile for: %s", browserName);
+    if (!profilePath) {
+        logger.verbose("No browser profile path declared, skipping...");
+        return;
+    }
+    if (existsSync(profilePath)) {
+        if (readFileSync(profilePath, "utf8") === browserProfiles[browserName]) {
+            logger.verbose("Browser profile is up to date at: %s", profilePath);
+            return;
+        }
+        logger.verbose("Browser profile at %s is outdated, rewriting it", profilePath);
+    }
+    else {
+        logger.verbose("No browser profile created yet for %s", browserName);
+    }
+    createBrowserProfile(browserName, profilePath);
+}
+function createBrowserProfile(browserName, profilePath) {
+    logger.verbose("Creating browser profile for %s at %s", browserName, profilePath);
+    mkdirSync(path.dirname(profilePath), { recursive: true });
+    writeFileSync(profilePath, browserProfiles[browserName], {
+        encoding: "utf8",
+    });
+    logger.verbose("Browser profile created");
+}

package/dist/browser/context-tree.d.ts

@@ -0,0 +1,23 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { BrowsingContext } from "../types/bidi-modules/browsing-context.js";
+/**
+ * Tracks which browsing contexts (iframes) belong to which top-level context, so events that
+ * carry a child context id can be attributed to the page that owns it.
+ * Destroyed contexts stay known: late events for them must still resolve to their page.
+ */
+export declare class ContextTree {
+    private connector;
+    private subscription;
+    private parents;
+    private constructor();
+    static create(connector: BiDiConnector): Promise<ContextTree>;
+    private onContext;
+    private add;
+    /** The direct parent, or null for a top-level or unknown context */
+    parentOf(context: BrowsingContext): BrowsingContext | null;
+    /** The top-level context that contains `context`; an unknown context is its own root */
+    rootOf(context: BrowsingContext): BrowsingContext;
+    /** True when `context` is `root` or one of its descendants; false for unknown contexts */
+    isWithin(context: BrowsingContext, root: BrowsingContext): boolean;
+    dispose(): Promise<void>;
+}

package/dist/browser/context-tree.js

@@ -0,0 +1,60 @@
+/**
+ * Tracks which browsing contexts (iframes) belong to which top-level context, so events that
+ * carry a child context id can be attributed to the page that owns it.
+ * Destroyed contexts stay known: late events for them must still resolve to their page.
+ */
+export class ContextTree {
+    constructor(connector, subscription) {
+        this.connector = connector;
+        this.subscription = subscription;
+        this.parents = new Map();
+        this.onContext = (info) => this.add(info);
+    }
+    static async create(connector) {
+        // Subscribe first: a context created between getTree and subscribing would be missed
+        const subscription = await connector.subscribe([
+            "browsingContext.contextCreated",
+            "browsingContext.contextDestroyed",
+        ]);
+        const tree = new ContextTree(connector, subscription);
+        connector.onEvent("browsingContext.contextCreated", tree.onContext);
+        connector.onEvent("browsingContext.contextDestroyed", tree.onContext);
+        try {
+            const { contexts } = await connector.send("browsingContext.getTree", {});
+            contexts.forEach((info) => tree.add(info));
+        }
+        catch (err) {
+            await tree.dispose();
+            throw err;
+        }
+        return tree;
+    }
+    add(info) {
+        this.parents.set(info.context, info.parent ?? null);
+        info.children?.forEach((child) => this.add(child));
+    }
+    /** The direct parent, or null for a top-level or unknown context */
+    parentOf(context) {
+        return this.parents.get(context) ?? null;
+    }
+    /** The top-level context that contains `context`; an unknown context is its own root */
+    rootOf(context) {
+        let current = context;
+        for (let parent = this.parentOf(current); parent !== null; parent = this.parentOf(current)) {
+            current = parent;
+        }
+        return current;
+    }
+    /** True when `context` is `root` or one of its descendants; false for unknown contexts */
+    isWithin(context, root) {
+        if (context === root)
+            return true;
+        return this.parents.has(context) && this.rootOf(context) === root;
+    }
+    async dispose() {
+        this.connector.offEvent("browsingContext.contextCreated", this.onContext);
+        this.connector.offEvent("browsingContext.contextDestroyed", this.onContext);
+        this.parents.clear();
+        await this.subscription.unsubscribe();
+    }
+}

package/dist/browser/dialog.d.ts

@@ -0,0 +1,37 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import type { UserPromptOpenedParameters, UserPromptType } from "../types/bidi-modules/browsing-context.js";
+export interface DialogResult {
+    accepted: boolean;
+    /** What was typed into a `prompt` */
+    userText?: string;
+}
+/**
+ * A JavaScript dialog (`alert`, `confirm`, `prompt`) or a `beforeunload` prompt that is open in the page.
+ * Answer it once with `accept()` or `dismiss()`; `page.on("dialog")` hands these out.
+ */
+export declare class Dialog {
+    private connector;
+    /** The top-level context of the page; prompts are answered there, also when an iframe opened them */
+    private context;
+    private info;
+    /** Resolves when the browser reports the prompt closed */
+    readonly closed: Promise<DialogResult>;
+    private resolveClosed;
+    private answered;
+    constructor(connector: BiDiConnector, 
+    /** The top-level context of the page; prompts are answered there, also when an iframe opened them */
+    context: string, info: UserPromptOpenedParameters);
+    type(): UserPromptType;
+    message(): string;
+    /** The text a `prompt` starts with; empty for the other kinds */
+    defaultValue(): string;
+    /** True once the dialog is answered, by you or by the browser */
+    get handled(): boolean;
+    /** Clicks OK; `promptText` is typed into a `prompt` first */
+    accept(promptText?: string): Promise<void>;
+    /** Clicks Cancel */
+    dismiss(): Promise<void>;
+    /** Called by the page when the browser reports the prompt closed */
+    markClosed(result: DialogResult): void;
+    private answer;
+}

package/dist/browser/dialog.js

@@ -0,0 +1,61 @@
+import { BiDiError } from "../transport/bidi-error.js";
+/**
+ * A JavaScript dialog (`alert`, `confirm`, `prompt`) or a `beforeunload` prompt that is open in the page.
+ * Answer it once with `accept()` or `dismiss()`; `page.on("dialog")` hands these out.
+ */
+export class Dialog {
+    constructor(connector, 
+    /** The top-level context of the page; prompts are answered there, also when an iframe opened them */
+    context, info) {
+        this.connector = connector;
+        this.context = context;
+        this.info = info;
+        this.closed = new Promise((resolve) => (this.resolveClosed = resolve));
+        // With another handler than "ignore" the browser has answered already
+        this.answered = info.handler !== "ignore";
+    }
+    type() {
+        return this.info.type;
+    }
+    message() {
+        return this.info.message;
+    }
+    /** The text a `prompt` starts with; empty for the other kinds */
+    defaultValue() {
+        return this.info.defaultValue ?? "";
+    }
+    /** True once the dialog is answered, by you or by the browser */
+    get handled() {
+        return this.answered;
+    }
+    /** Clicks OK; `promptText` is typed into a `prompt` first */
+    accept(promptText) {
+        return this.answer({ accept: true, ...(promptText !== undefined && { userText: promptText }) });
+    }
+    /** Clicks Cancel */
+    dismiss() {
+        return this.answer({ accept: false });
+    }
+    /** Called by the page when the browser reports the prompt closed */
+    markClosed(result) {
+        this.answered = true;
+        this.resolveClosed(result);
+    }
+    async answer(params) {
+        if (this.answered)
+            throw new Error("dialog already handled");
+        this.answered = true;
+        try {
+            await this.connector.send("browsingContext.handleUserPrompt", {
+                context: this.context,
+                ...params,
+            });
+        }
+        catch (err) {
+            // Closed meanwhile (a navigation, another handler): the dialog is gone, which is what was wanted
+            if (err instanceof BiDiError && err.code === "no such alert")
+                return;
+            throw err;
+        }
+    }
+}

package/dist/browser/download.d.ts

@@ -0,0 +1,71 @@
+import type { BiDiConnector } from "../transport/bidi-connection.js";
+import { WaitTimeoutError } from "../wait/wait-until.js";
+import type { ContextTree } from "./context-tree.js";
+/** A download did not complete */
+export declare class DownloadError extends Error {
+    readonly url: string;
+    /** "canceled": the browser stopped it or the server broke the connection; "page closed" */
+    readonly reason: string;
+    constructor(url: string, reason: string);
+}
+/** A download did not finish in time */
+export declare class DownloadTimeoutError extends WaitTimeoutError<undefined> {
+    constructor(url: string, timeout: number);
+}
+type Outcome = {
+    status: "complete";
+    path: string;
+} | {
+    status: "canceled";
+} | {
+    status: "closed";
+};
+/** A file the page started to download */
+export declare class Download {
+    private readonly address;
+    private readonly filename;
+    private readonly defaultTimeout;
+    private settle;
+    private outcome;
+    constructor(address: string, filename: string, defaultTimeout: number);
+    url(): string;
+    /** The name the server (or the link) suggested */
+    suggestedFilename(): string;
+    /**
+     * Waits until the download finished and returns where the browser saved it. Rejects with DownloadError when it was
+     * cancelled, and with DownloadTimeoutError after `timeout` ms (default: the navigation timeout).
+     */
+    path(options?: {
+        timeout?: number;
+    }): Promise<string>;
+    /** Waits for the end of the download: null when it completed, otherwise why it did not ("canceled") */
+    failure(): Promise<string | null>;
+    /** @internal */
+    finish(outcome: Outcome): void;
+}
+interface EventMap {
+    download: [Download];
+}
+/** Follows the downloads of one page (frames included) */
+export declare class DownloadTracker {
+    private connector;
+    private tree;
+    private contextId;
+    private timeout;
+    private events;
+    private active;
+    private subscription;
+    private disposed;
+    private constructor();
+    static start(connector: BiDiConnector, tree: ContextTree, contextId: string, options: {
+        timeout: number;
+    }): Promise<DownloadTracker>;
+    on(event: "download", listener: (...args: EventMap["download"]) => void): void;
+    off(event: "download", listener: (...args: EventMap["download"]) => void): void;
+    /** Stops tracking; downloads still going on reject with "page closed". Idempotent */
+    dispose(): Promise<void>;
+    private removeListeners;
+    private onBegin;
+    private onEnd;
+}
+export {};