xpe 0.0.0-alpha.1 → 1.0.0

package/dist/host/app-path-router.d.ts

@@ -0,0 +1,33 @@
+import type { AppManifest, AppNavigationTarget, Unsubscribe } from "../core/index.js";
+import type { RuntimeContainer } from "../kernel/index.js";
+import type { HostRuntime } from "./host-runtime.js";
+export type AppPathRouteMode = "push" | "replace";
+export type AppPathRoute = {
+    manifest: AppManifest;
+    routePath: string;
+};
+export type AppPathRouterApp = {
+    manifest: AppManifest;
+    appPath?: string;
+    defaultPath?: string;
+};
+export type CreateAppPathRouterOptions = {
+    host: HostRuntime;
+    apps: AppPathRouterApp[];
+    container: RuntimeContainer;
+    getCurrentUrl?: () => URL;
+    writeUrl?: (url: URL, mode: AppPathRouteMode) => void;
+    onRouteChange?: (route: AppPathRoute) => void;
+    defaultAppCode?: string;
+};
+export type AppPathRouter = {
+    current(): AppPathRoute;
+    start(options?: {
+        replaceInvalidUrl?: boolean;
+    }): Promise<void>;
+    navigate(appCode: string, routePath?: string | AppNavigationTarget, mode?: AppPathRouteMode): Promise<void>;
+    reload(): Promise<void>;
+    handleBrowserNavigation(): Promise<void>;
+    attach(): Unsubscribe;
+};
+export declare function createAppPathRouter(options: CreateAppPathRouterOptions): AppPathRouter;

package/dist/host/app-path-router.js

@@ -0,0 +1,183 @@
+import { XpeRuntimeError } from "../core/index.js";
+export function createAppPathRouter(options) {
+    if (!options.apps.length) {
+        throw new XpeRuntimeError("XPE_APP_NOT_REGISTERED", "XPE app path router 至少需要注册一个应用", {});
+    }
+    let activeAppCode = null;
+    let activeRouteKey = null;
+    let routeTask = Promise.resolve();
+    const getCurrentUrl = options.getCurrentUrl ?? (() => new URL(window.location.href));
+    const writeUrl = options.writeUrl ??
+        ((url, mode) => {
+            window.history[mode === "push" ? "pushState" : "replaceState"](null, "", url.href);
+        });
+    async function start(startOptions = {}) {
+        await enqueueRoute(async () => {
+            const route = current();
+            if (startOptions.replaceInvalidUrl && !findAppByPath(getCurrentUrl().pathname)) {
+                writeAppUrl(route.manifest, route.routePath, "replace");
+            }
+            await applyRoute(route);
+        });
+    }
+    async function navigate(appCode, routePath, mode = "push") {
+        const navigation = resolveNavigationTarget(appCode, routePath, mode);
+        const app = findAppByCode(navigation.appCode);
+        if (!app) {
+            throw new XpeRuntimeError("XPE_APP_NOT_REGISTERED", `XPE app path router 找不到应用：${navigation.appCode}`, {
+                appCode: navigation.appCode,
+            });
+        }
+        const normalizedRoute = normalizeRoutePath(navigation.path ?? getDefaultPath(app));
+        writeAppUrl(app.manifest, normalizedRoute, navigation.mode);
+        await enqueueRoute(() => applyRoute({ manifest: app.manifest, routePath: normalizedRoute }));
+    }
+    async function reload() {
+        await enqueueRoute(() => applyRoute(current(), { forceReload: true }));
+    }
+    async function handleBrowserNavigation() {
+        await enqueueRoute(() => applyRoute(current()));
+    }
+    async function applyRoute(route, applyOptions = {}) {
+        const nextRouteKey = toRouteKey(route);
+        if (!applyOptions.forceReload && activeRouteKey === nextRouteKey)
+            return;
+        const manifest = withRuntimeRoute(route.manifest, route.routePath, getCurrentUrl());
+        options.onRouteChange?.({ manifest, routePath: route.routePath });
+        if (!applyOptions.forceReload && activeAppCode === manifest.appCode) {
+            options.host.navigate(manifest.appCode, route.routePath);
+            activeRouteKey = nextRouteKey;
+            return;
+        }
+        if (applyOptions.forceReload && activeAppCode)
+            await options.host.destroy(activeAppCode);
+        await options.host.start({ manifest, container: options.container });
+        activeAppCode = manifest.appCode;
+        activeRouteKey = nextRouteKey;
+    }
+    function attach() {
+        const targetWindow = window;
+        const handleNavigation = () => {
+            void handleBrowserNavigation();
+        };
+        targetWindow.addEventListener("hashchange", handleNavigation);
+        targetWindow.addEventListener("popstate", handleNavigation);
+        return () => {
+            targetWindow.removeEventListener("hashchange", handleNavigation);
+            targetWindow.removeEventListener("popstate", handleNavigation);
+        };
+    }
+    function current() {
+        const url = getCurrentUrl();
+        const app = findAppByPath(url.pathname) ?? getDefaultApp();
+        return {
+            manifest: app.manifest,
+            routePath: normalizeRoutePath(url.hash.replace(/^#/, "") || getDefaultPath(app)),
+        };
+    }
+    function writeAppUrl(manifest, routePath, mode) {
+        const url = getCurrentUrl();
+        url.pathname = withTrailingSlash(getAppPath(manifest));
+        url.search = "";
+        url.hash = normalizeRoutePath(routePath);
+        if (url.href !== getCurrentUrl().href)
+            writeUrl(url, mode);
+    }
+    function findAppByPath(pathname) {
+        const normalizedPathname = normalizePathname(pathname);
+        return options.apps.find((app) => normalizePathname(getAppPath(app.manifest, app.appPath)) === normalizedPathname);
+    }
+    function findAppByCode(appCode) {
+        return options.apps.find((app) => app.manifest.appCode === appCode);
+    }
+    function getDefaultApp() {
+        return (options.defaultAppCode ? findAppByCode(options.defaultAppCode) : undefined) ?? options.apps[0];
+    }
+    return {
+        current,
+        start,
+        navigate,
+        reload,
+        handleBrowserNavigation,
+        attach,
+    };
+    function enqueueRoute(task) {
+        const nextTask = routeTask.then(task, task);
+        routeTask = nextTask.catch(() => undefined);
+        return nextTask;
+    }
+    function resolveNavigationTarget(appCode, routePath, mode) {
+        if (typeof routePath === "object" && routePath) {
+            return {
+                appCode: routePath.appCode ?? appCode,
+                path: formatRoutePath(routePath.path, routePath.query),
+                mode: routePath.replace ? "replace" : mode,
+            };
+        }
+        return {
+            appCode,
+            path: typeof routePath === "string" ? routePath : undefined,
+            mode,
+        };
+    }
+}
+function getAppPath(manifest, appPath) {
+    return appPath ?? manifest.basePath;
+}
+function getDefaultPath(app) {
+    return app.defaultPath ?? "/";
+}
+function normalizeRoutePath(path) {
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function formatRoutePath(path, query) {
+    const normalizedPath = normalizeRoutePath(path);
+    const search = formatQuery(query);
+    if (!search)
+        return normalizedPath;
+    return normalizedPath.includes("?") ? `${normalizedPath}&${search.slice(1)}` : `${normalizedPath}${search}`;
+}
+function formatQuery(query) {
+    if (!query)
+        return "";
+    const params = new URLSearchParams();
+    Object.entries(query).forEach(([key, value]) => {
+        const values = Array.isArray(value) ? value : [value];
+        values.forEach((item) => {
+            if (item === null || item === undefined)
+                return;
+            params.append(key, String(item));
+        });
+    });
+    const queryString = params.toString();
+    return queryString ? `?${queryString}` : "";
+}
+function normalizePathname(pathname) {
+    return pathname.length > 1 ? pathname.replace(/\/$/, "") : pathname;
+}
+function withTrailingSlash(pathname) {
+    return pathname.endsWith("/") ? pathname : `${pathname}/`;
+}
+function toRouteKey(route) {
+    return `${route.manifest.appCode}:${normalizeRoutePath(route.routePath)}`;
+}
+function withRuntimeRoute(manifest, routePath, baseUrl) {
+    const runtimeUrl = new URL(manifest.runtime.url, baseUrl.href);
+    const normalizedRoute = normalizeRoutePath(routePath);
+    if ((manifest.runtime.routeMode ?? "hash") === "hash") {
+        runtimeUrl.hash = normalizedRoute;
+    }
+    else {
+        runtimeUrl.pathname = joinPath(manifest.runtime.basename ?? manifest.basePath, normalizedRoute);
+    }
+    return {
+        ...manifest,
+        runtime: {
+            ...manifest.runtime,
+            url: runtimeUrl.href,
+        },
+    };
+}
+function joinPath(basePath, routePath) {
+    return `${basePath.replace(/\/$/, "")}/${routePath.replace(/^\//, "")}`;
+}

package/dist/host/host-runtime.d.ts

@@ -0,0 +1,29 @@
+import { type AppBridge, type AppContext, type AppEventHandler, type HostNavigationTarget, type AppNavigationTarget, type AppManifest, type Unsubscribe } from "../core/index.js";
+import { type RuntimeContainer, type RuntimeKernel } from "../kernel/index.js";
+export type HostRuntimeOptions = {
+    getEntryContext: (appCode: string) => AppContext | Promise<AppContext>;
+    runtimeKernel?: RuntimeKernel;
+    onUnauthorized?: (context: AppContext) => void;
+    onRouteChange?: (event: {
+        appCode: string;
+        target: string | AppNavigationTarget;
+    }) => void;
+    onHostNavigate?: (target: string | HostNavigationTarget) => void;
+    onError?: (error: unknown) => void;
+};
+export type StartAppOptions = {
+    manifest: AppManifest;
+    container: RuntimeContainer;
+};
+export type HostRuntime = {
+    register(manifest: AppManifest): void;
+    getManifest(appCode: string): AppManifest | undefined;
+    preload(manifest: AppManifest): void;
+    start(options: StartAppOptions): Promise<AppBridge>;
+    navigate(appCode: string, path: string): void;
+    emit<TPayload = unknown>(appCode: string, eventName: string, payload: TPayload): void;
+    on<TPayload = unknown>(appCode: string, eventName: string, handler: AppEventHandler<TPayload>): Unsubscribe;
+    off<TPayload = unknown>(appCode: string, eventName: string, handler: AppEventHandler<TPayload>): void;
+    destroy(appCode: string): Promise<void>;
+};
+export declare function createHostRuntime(options: HostRuntimeOptions): HostRuntime;

package/dist/host/host-runtime.js

@@ -0,0 +1,176 @@
+import { createEventHub, XPE_ROUTE_CHANGE_EVENT, XpeRuntimeError, } from "../core/index.js";
+import { createRuntimeKernel } from "../kernel/index.js";
+export function createHostRuntime(options) {
+    const manifests = new Map();
+    const bridges = new Map();
+    const appEvents = new Map();
+    const runtimeKernel = options.runtimeKernel ?? createRuntimeKernel();
+    function getAppEvents(appCode) {
+        let eventHub = appEvents.get(appCode);
+        if (!eventHub) {
+            eventHub = createEventHub();
+            appEvents.set(appCode, eventHub);
+        }
+        return eventHub;
+    }
+    return {
+        register(manifest) {
+            manifests.set(manifest.appCode, normalizeManifest(manifest));
+        },
+        getManifest(appCode) {
+            return manifests.get(appCode);
+        },
+        preload(manifest) {
+            const normalizedManifest = normalizeManifest(manifest);
+            manifests.set(normalizedManifest.appCode, normalizedManifest);
+            runtimeKernel.preload({ manifest: normalizedManifest });
+        },
+        async start(startOptions) {
+            const manifest = normalizeManifest(startOptions.manifest);
+            manifests.set(manifest.appCode, manifest);
+            try {
+                const context = await options.getEntryContext(manifest.appCode);
+                // 未授权是一条独立的业务分支，只走 onUnauthorized，不再经 onError，
+                // 避免「一次未授权同时触发 onUnauthorized + onError」的重复派发。
+                // 仍然 reject，让 await start() 的调用方能感知进入被拒绝。
+                if (context.accessStatus !== "enterable") {
+                    options.onUnauthorized?.(context);
+                    throw new XpeRuntimeError("XPE_APP_NOT_ENTERABLE", "XPE 应用当前不可进入", {
+                        appCode: manifest.appCode,
+                        accessStatus: context.accessStatus,
+                        reason: context.reason,
+                    });
+                }
+                const bridge = createHostBridge({
+                    manifest,
+                    context,
+                    appEvents: getAppEvents(manifest.appCode),
+                    onRouteChange: options.onRouteChange,
+                    onHostNavigate: options.onHostNavigate,
+                });
+                bridges.set(manifest.appCode, bridge);
+                await runtimeKernel.start({
+                    manifest,
+                    context,
+                    container: startOptions.container,
+                    bridge,
+                });
+                return bridge;
+            }
+            catch (error) {
+                // 未授权已由 onUnauthorized 派发，不再重复走 onError；其余错误（getEntryContext
+                // 失败、kernel 启动失败等）才交给 onError。
+                if (!(error instanceof XpeRuntimeError && error.code === "XPE_APP_NOT_ENTERABLE")) {
+                    options.onError?.(error);
+                }
+                throw error;
+            }
+        },
+        navigate(appCode, path) {
+            const bridge = bridges.get(appCode);
+            bridge?.syncRoute?.(path);
+        },
+        emit(appCode, eventName, payload) {
+            getAppEvents(appCode).emit(eventName, payload);
+        },
+        on(appCode, eventName, handler) {
+            return getAppEvents(appCode).on(eventName, handler);
+        },
+        off(appCode, eventName, handler) {
+            getAppEvents(appCode).off(eventName, handler);
+        },
+        async destroy(appCode) {
+            const manifest = manifests.get(appCode);
+            if (manifest) {
+                await runtimeKernel.destroy({
+                    appCode,
+                    runtime: normalizeRuntimeConfig(manifest.appCode, manifest.basePath, manifest.runtime),
+                });
+            }
+            bridges.delete(appCode);
+            // 清理 per-app 事件 hub，否则反复 register/start/destroy 会累积 hub 及其上注册的
+            // host.on 处理器，活到整个 runtime 生命周期结束，形成真实泄漏。
+            const eventHub = appEvents.get(appCode);
+            if (eventHub) {
+                eventHub.clear();
+                appEvents.delete(appCode);
+            }
+        },
+    };
+}
+function createHostBridge(options) {
+    let currentContext = options.context;
+    const contextEvents = createEventHub();
+    const runtime = {
+        poweredByXpe: true,
+        appCode: options.manifest.appCode,
+        name: getRuntimeName(options.manifest.appCode, options.manifest.runtime),
+        basename: getRuntimeBasename(options.manifest.basePath, options.manifest.runtime),
+        routeMode: options.manifest.runtime.routeMode ?? "hash",
+    };
+    const bridge = {
+        runtime,
+        get context() {
+            return currentContext;
+        },
+        getContext() {
+            return currentContext;
+        },
+        setContext(nextContext) {
+            currentContext = nextContext;
+            contextEvents.emit("context-change", nextContext);
+        },
+        onContextChange(handler) {
+            return contextEvents.on("context-change", handler);
+        },
+        emit(eventName, payload) {
+            options.appEvents.emit(eventName, payload);
+        },
+        on(eventName, handler) {
+            return options.appEvents.on(eventName, handler);
+        },
+        off(eventName, handler) {
+            options.appEvents.off(eventName, handler);
+        },
+        navigate(target) {
+            options.onRouteChange?.({ appCode: options.manifest.appCode, target });
+        },
+        navigateHost(target) {
+            options.onHostNavigate?.(target);
+        },
+        reportRouteChange(path) {
+            options.onRouteChange?.({ appCode: options.manifest.appCode, target: path });
+        },
+        syncRoute(path) {
+            options.appEvents.emit(XPE_ROUTE_CHANGE_EVENT, path);
+        },
+    };
+    return bridge;
+}
+function normalizeManifest(manifest) {
+    return {
+        ...manifest,
+        entryPath: manifest.entryPath ?? toEntryPath(manifest.basePath),
+        runtimeMode: manifest.runtimeMode ?? "xpe",
+        runtime: normalizeRuntimeConfig(manifest.appCode, manifest.basePath, manifest.runtime),
+        menus: manifest.menus ?? [],
+        permissions: manifest.permissions ?? [],
+    };
+}
+function normalizeRuntimeConfig(appCode, basePath, runtime) {
+    return {
+        ...runtime,
+        mode: runtime.mode ?? "xpe",
+        name: getRuntimeName(appCode, runtime),
+        basename: getRuntimeBasename(basePath, runtime),
+    };
+}
+function getRuntimeName(appCode, runtime) {
+    return runtime.name ?? appCode;
+}
+function getRuntimeBasename(basePath, runtime) {
+    return runtime.basename ?? basePath;
+}
+function toEntryPath(basePath) {
+    return `${basePath.replace(/\/$/, "")}/#/`;
+}

package/dist/host/index.d.ts

@@ -0,0 +1 @@
+export * from "./xpe-host.js";

package/dist/host/index.js

@@ -0,0 +1 @@
+export * from "./xpe-host.js";

package/dist/host/xpe-host.d.ts

@@ -0,0 +1,41 @@
+import type { AppContext, AppEventHandler, AppManifest, AppNavigationTarget, HostNavigationTarget, Unsubscribe } from "../core/index.js";
+import type { RuntimeContainer, RuntimeKernel } from "../kernel/index.js";
+import { type AppPathRoute, type AppPathRouter, type AppPathRouterApp, type AppPathRouteMode } from "./app-path-router.js";
+import { type HostRuntime } from "./host-runtime.js";
+export type HostOptions = {
+    container: RuntimeContainer;
+    apps: AppPathRouterApp[];
+    getEntryContext: (appCode: string) => AppContext | Promise<AppContext>;
+    defaultAppCode?: string;
+    runtimeKernel?: RuntimeKernel;
+    onUnauthorized?: (context: AppContext) => void;
+    onRouteChange?: (route: AppPathRoute) => void;
+    onNavigate?: (event: {
+        appCode: string;
+        target: string | AppNavigationTarget;
+    }) => void;
+    onHostNavigate?: (target: string | HostNavigationTarget) => void;
+    getCurrentUrl?: () => URL;
+    writeUrl?: (url: URL, mode: AppPathRouteMode) => void;
+    autoAttach?: boolean;
+    onError?: (error: unknown) => void;
+};
+export type Host = {
+    runtime: HostRuntime;
+    router: AppPathRouter;
+    start(options?: {
+        replaceInvalidUrl?: boolean;
+    }): Promise<void>;
+    navigate(appCode: string, routePath?: string | AppNavigationTarget): Promise<void>;
+    emit<TPayload = unknown>(appCode: string, eventName: string, payload: TPayload): void;
+    on<TPayload = unknown>(appCode: string, eventName: string, handler: AppEventHandler<TPayload>): Unsubscribe;
+    off<TPayload = unknown>(appCode: string, eventName: string, handler: AppEventHandler<TPayload>): void;
+    reload(): Promise<void>;
+    preload(manifest: AppManifest): void;
+    destroy(appCode: string): Promise<void>;
+    dispose(): void;
+};
+export type XpeHostOptions = HostOptions;
+export type XpeHost = Host;
+export declare function createHost(options: HostOptions): Host;
+export declare const createXpeHost: typeof createHost;

package/dist/host/xpe-host.js

@@ -0,0 +1,61 @@
+import { createAppPathRouter, } from "./app-path-router.js";
+import { createHostRuntime } from "./host-runtime.js";
+export function createHost(options) {
+    let detachRouter;
+    const runtime = createHostRuntime({
+        getEntryContext: options.getEntryContext,
+        runtimeKernel: options.runtimeKernel,
+        onUnauthorized: options.onUnauthorized,
+        onError: options.onError,
+        onHostNavigate: options.onHostNavigate,
+        onRouteChange(event) {
+            options.onNavigate?.(event);
+            void router.navigate(event.appCode, event.target);
+        },
+    });
+    const router = createAppPathRouter({
+        host: runtime,
+        container: options.container,
+        apps: options.apps,
+        defaultAppCode: options.defaultAppCode,
+        onRouteChange: options.onRouteChange,
+        getCurrentUrl: options.getCurrentUrl,
+        writeUrl: options.writeUrl,
+    });
+    return {
+        runtime,
+        router,
+        async start(startOptions = { replaceInvalidUrl: true }) {
+            if (options.autoAttach !== false) {
+                detachRouter ?? (detachRouter = router.attach());
+            }
+            await router.start(startOptions);
+        },
+        navigate(appCode, routePath) {
+            return router.navigate(appCode, routePath);
+        },
+        emit(appCode, eventName, payload) {
+            runtime.emit(appCode, eventName, payload);
+        },
+        on(appCode, eventName, handler) {
+            return runtime.on(appCode, eventName, handler);
+        },
+        off(appCode, eventName, handler) {
+            runtime.off(appCode, eventName, handler);
+        },
+        reload() {
+            return router.reload();
+        },
+        preload(manifest) {
+            runtime.preload(manifest);
+        },
+        destroy(appCode) {
+            return runtime.destroy(appCode);
+        },
+        dispose() {
+            detachRouter?.();
+            detachRouter = undefined;
+        },
+    };
+}
+export const createXpeHost = createHost;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./core/index.js";
+export * from "./host/index.js";
+export * from "./child/index.js";
+export * from "./dev-shell/index.js";

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./core/index.js";
+export * from "./host/index.js";
+export * from "./child/index.js";
+export * from "./dev-shell/index.js";

package/dist/kernel/common.d.ts

@@ -0,0 +1,62 @@
+import RuntimeSandbox from "./sandbox.js";
+import { cacheOptions } from "./runtime-engine.js";
+export interface SandboxCache {
+    sandbox?: RuntimeSandbox;
+    options?: cacheOptions;
+}
+export type appAddEventListenerOptions = AddEventListenerOptions & {
+    targetWindow?: Window;
+};
+export declare const idToSandboxCacheMap: Map<String, SandboxCache>;
+export declare function getSandboxById(id: String): RuntimeSandbox | null;
+export declare function getOptionsById(id: String): cacheOptions | null;
+export declare function addSandboxCacheWithSandbox(id: string, sandbox: RuntimeSandbox): void;
+export declare function deleteSandboxById(id: string): void;
+export declare function addSandboxCacheWithOptions(id: string, options: cacheOptions): void;
+export declare const documentProxyProperties: {
+    modifyLocalProperties: string[];
+    modifyProperties: string[];
+    shadowProperties: string[];
+    shadowMethods: string[];
+    documentProperties: string[];
+    documentMethods: string[];
+    documentEvents: string[];
+    ownerProperties: string[];
+};
+export declare const appDocumentAddEventListenerEvents: string[];
+export declare const appDocumentOnEvents: string[];
+export declare const mainDocumentAddEventListenerEvents: string[];
+export declare const mainAndAppAddEventListenerEvents: string[];
+export declare const appWindowAddEventListenerEvents: string[];
+export declare const appWindowOnEvent: string[];
+export declare const relativeElementTagAttrMap: {
+    IMG: string;
+    A: string;
+    SOURCE: string;
+};
+export declare const windowProxyProperties: string[];
+export declare const windowRegWhiteList: RegExp[];
+export declare const rawElementAppendChild: <T extends Node>(node: T) => T;
+export declare const rawElementRemoveChild: <T extends Node>(child: T) => T;
+export declare const rawElementContains: (other: Node | null) => boolean;
+export declare const rawHeadInsertBefore: <T extends Node>(node: T, child: Node | null) => T;
+export declare const rawBodyInsertBefore: <T extends Node>(node: T, child: Node | null) => T;
+export declare const rawInsertAdjacentElement: (where: InsertPosition, element: Element) => Element | null;
+export declare const rawAddEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean) => void;
+export declare const rawRemoveEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean) => void;
+export declare const rawWindowAddEventListener: {
+    <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+} & typeof addEventListener;
+export declare const rawWindowRemoveEventListener: {
+    <K extends keyof WindowEventMap>(type: K, listener: (this: Window, ev: WindowEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+} & typeof removeEventListener;
+export declare const rawAppendChild: <T extends Node>(node: T) => T;
+export declare const rawDocumentQuerySelector: {
+    <K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+    <K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+    <K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+    <K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+    <E extends Element = Element>(selectors: string): E | null;
+};