@tempots/dom 23.0.1 → 24.0.0-next.0

package/dom/attr.d.ts

@@ -1,58 +1,3 @@
-/**
- * Sets a boolean property on an HTML element.
- *
- * If the `value` is `null`, the property is set to `null`. Otherwise, the
- * property is set to the boolean value of `value`.
- *
- * @param attributeName - The name of the boolean property to set.
- * @returns A function that takes an `Element` and a `value` and sets the
- * boolean property on the element.
- * @internal
- */
-export declare const _setBooleanProperty: (attributeName: string) => (element: Element, value: unknown) => void;
-/**
- * Sets a numeric property on an HTML element.
- *
- * If the provided `value` is `null`, the property will be set to `null`.
- * Otherwise, the property will be set to the numeric value of the provided `value`.
- *
- * @param attributeName - The name of the property to set on the element.
- * @returns A function that takes an `Element` and a `value` and sets the property.
- * @internal
- */
-export declare const _setNumberProperty: (attributeName: string) => (element: Element, value: unknown) => void;
-/**
- * Sets a date property on an element.
- *
- * If the `value` is `null`, the date property is set to `null`. Otherwise, the
- * date property is set to the provided `value`.
- *
- * @param attributeName - The name of the date property to set on the element.
- * @returns A function that takes an element and a value, and sets the date
- * property on the element.
- * @internal
- */
-export declare const _setDateProperty: (attributeName: string) => (element: Element, value: unknown) => void;
-/**
- * Sets a string property on an `Element` object.
- *
- * If the provided `value` is `null`, the property will be set to `null`.
- * Otherwise, the `value` will be converted to a string and set as the property.
- *
- * @param attributeName - The name of the property to set on the `Element`.
- * @returns A function that takes an `Element` and a `value` and sets the property.
- * @internal
- */
-export declare const _setStringProperty: (attributeName: string) => (element: Element, value: unknown) => void;
-/**
- * Sets the specified attribute on the given element to the provided value.
- * If the value is `null`, the attribute will be removed from the element.
- *
- * @param attributeName - The name of the attribute to set.
- * @returns A function that takes an element and a value, and sets the attribute on the element.
- * @internal
- */
-export declare const _setAttribute: (attributeName: string) => (element: Element, value: unknown) => void;
 /**
  * Creates a setter function for an element attribute based on the attribute's type.
  *
@@ -64,7 +9,7 @@ export declare const _setAttribute: (attributeName: string) => (element: Element
  * @returns A function that sets the attribute value on an element.
  * @internal
  */
-export declare const _makeSetter: (attributeName: string) => ((element: Element, value: unknown) => void);
+export declare const _makeSetter: (attributeName: string, element: Element) => (value: unknown) => void;
 /**
  * Creates a getter function for a specific HTML element attribute.
  *
@@ -77,4 +22,4 @@ export declare const _makeSetter: (attributeName: string) => ((element: Element,
  * specified attribute.
  * @internal
  */
-export declare const _makeGetter: <T>(attributeName: string) => ((element: Element) => T);
+export declare const _makeGetter: (attributeName: string, element: Element) => () => any;

package/dom/browser-context.d.ts

@@ -0,0 +1,198 @@
+import { Clear, ProviderMark, Providers } from '../types/domain';
+import { DOMContext } from './dom-context';
+import { HeadlessContext } from './headless-context';
+/**
+ * `DOMContext` is an immutable class that represents the context of a DOM element.
+ * It provides methods and properties to manipulate and interact with the DOM element.
+ *
+ * A reference in a DOMContext is to mark a position within a set of sibblings.
+ * It is used to insert new elements before the reference.
+ *
+ * @public
+ */
+export declare class BrowserContext implements DOMContext {
+    /**
+     * The `Document` instance associated with this context.
+     */
+    readonly document: Document;
+    /**
+     * The `Element` instance associated with this context.
+     */
+    readonly element: HTMLElement;
+    /**
+     * An optional `Node` instance that serves as a reference for this context.
+     */
+    readonly reference: Node | undefined;
+    /**
+     * The `Providers` instance associated with this context.
+     */
+    readonly providers: Providers;
+    /**
+     * Creates a new `DOMContext` instance for the given `Element` and optional reference `Node`.
+     *
+     * @param element - The `HTMLElement` to create the `DOMContext` for.
+     * @param ref - An optional reference `Node` to associate with the `DOMContext`.
+     * @returns A new `DOMContext` instance.
+     */
+    static of(element: HTMLElement, ref?: Node | undefined): DOMContext;
+    /**
+     * Constructs a new `DOMContext` instance.
+     *
+     * @param document - The `Document` instance associated with this context.
+     * @param element - The `Element` instance associated with this context.
+     * @param reference - An optional `Node` instance that serves as a reference for this context.
+     * @param providers - The `Providers` instance associated with this context.
+     * @param isFirstLevel - A boolean value indicating whether this context is at the first level, meaning the outermost node in the generated DOM.
+     */
+    constructor(
+    /**
+     * The `Document` instance associated with this context.
+     */
+    document: Document, 
+    /**
+     * The `Element` instance associated with this context.
+     */
+    element: HTMLElement, 
+    /**
+     * An optional `Node` instance that serves as a reference for this context.
+     */
+    reference: Node | undefined, 
+    /**
+     * The `Providers` instance associated with this context.
+     */
+    providers: Providers);
+    /**
+     * Creates a new DOM element (eg: HTML or SVG) with the specified tag name and namespace.
+     *
+     * @param tagName - The tag name of the element to create.
+     * @param namespace - The namespace URI to create the element in, or `undefined` to create a standard HTML element.
+     * @returns The newly created element.
+     */
+    readonly createElement: (tagName: string, namespace: string | undefined) => HTMLElement;
+    /**
+     * Creates a new DOM element (eg: HTML or SVG) with the specified tag name and namespace and appends it to the current element.
+     *
+     * @param tagName - The tag name of the element to create.
+     * @param namespace - The namespace URI to create the element in, or `undefined` to create a standard HTML element.
+     * @returns The newly created element.
+     */
+    readonly makeChildElement: (tagName: string, namespace: string | undefined) => DOMContext;
+    /**
+     * Creates a new text node with the specified text content.
+     * @param text - The text content for the new text node.
+     * @returns A new `Text` node with the specified text content.
+     */
+    readonly createText: (text: string) => Text;
+    /**
+     * Creates a new text node with the specified text content and appends it to the current element.
+     * @param text - The text content for the new text node.
+     * @returns A new `DOMContext` with a reference to the new text node.
+     */
+    readonly makeChildText: (text: string) => DOMContext;
+    /**
+     * Sets the text content of the current element.
+     * @param text - The text content to set.
+     */
+    readonly setText: (text: string) => void;
+    /**
+     * Gets the text content of the current element or text node.
+     * @returns The text content of the current element or text node.
+     */
+    readonly getText: () => string;
+    /**
+     * Creates a new `DOMContext` with a reference to a newly created text node.
+     * The text node is appended or inserted to the current `DOMContext`.
+     * The new `DOMContext` with the reference is returned.
+     */
+    readonly makeRef: () => DOMContext;
+    /**
+     * Appends or inserts a child node to the element, depending on whether a reference node is provided.
+     *
+     * @param child - The child node to append or insert.
+     */
+    readonly appendOrInsert: (child: Node) => void;
+    /**
+     * Creates a new `DOMContext` instance with the provided `element`.
+     * @param element - The DOM element to use in the new `DOMContext` instance.
+     * @returns A new `DOMContext` instance with the provided `element`.
+     */
+    readonly withElement: (element: HTMLElement) => BrowserContext;
+    /**
+     * Creates a new `DOMContext` instance with a reference to a DOM element selected by the provided `selector`.
+     * @param selector - The CSS selector for the target DOM element.
+     * @returns A new `DOMContext` instance with a reference to the selected DOM element.
+     */
+    readonly makePortal: (selector: string) => DOMContext;
+    /**
+     * Creates a new `DOMContext` instance with the specified reference.
+     *
+     * @param reference - The optional `Text` node to use as the reference for the new `DOMContext`.
+     * @returns A new `DOMContext` instance with the specified reference.
+     */
+    readonly withReference: (reference: Text | undefined) => DOMContext;
+    /**
+     * Returns a new HTMLDOMContext instance with the specified providers merged into
+     * the existing providers.
+     *
+     * @param providers - An object containing the providers to be merged into the existing providers.
+     * @returns A new HTMLDOMContext instance with the merged providers.
+     */
+    readonly withProviders: (providers: { [K in ProviderMark<unknown>]: unknown; }) => DOMContext;
+    /**
+     * Retrieves a provider for the given provider mark.
+     *
+     * @param mark - The provider mark to retrieve the provider for.
+     * @returns The provider for the given mark.
+     * @throws Throws `ProviderNotFoundError` if the provider for the given mark is not found.
+     */
+    readonly getProvider: <T>(mark: ProviderMark<T>) => T;
+    readonly clear: (removeTree: boolean) => void;
+    /**
+     * Adds classes to the element.
+     * @param tokens - The class names to add.
+     */
+    readonly addClasses: (tokens: string[]) => void;
+    /**
+     * Removes classes from the element.
+     * @param tokens - The class names to remove.
+     */
+    readonly removeClasses: (tokens: string[]) => void;
+    /**
+     * Gets the classes of the element.
+     * @returns The classes of the element.
+     */
+    readonly getClasses: () => string[];
+    /**
+     * Adds an event listener to the element.
+     * @param event - The event to listen for.
+     * @param listener - The listener to call when the event occurs.
+     * @returns A function to remove the event listener.
+     */
+    readonly on: <E>(event: string, listener: (event: E) => void) => Clear;
+    /**
+     * Returns `true` if the context is a browser DOM context.
+     * @returns `true` if the context is a browser DOM context.
+     */
+    readonly isBrowserDOM: () => this is BrowserContext;
+    /**
+     * Returns `true` if the context is a headless DOM context.
+     * @returns `true` if the context is a headless DOM context.
+     */
+    readonly isHeadlessDOM: () => this is HeadlessContext;
+    /**
+     * Sets the style of the element.
+     * @param name - The name of the style to set.
+     * @param value - The value of the style to set.
+     */
+    readonly setStyle: (name: string, value: string) => void;
+    /**
+     * Gets the style of the element.
+     * @param name - The name of the style to get.
+     * @returns The value of the style.
+     */
+    readonly getStyle: (name: string) => string;
+    readonly makeAccessors: (name: string) => {
+        get: () => any;
+        set: (value: unknown) => void;
+    };
+}

package/dom/dom-context.d.ts

@@ -1,4 +1,6 @@
-import { ProviderMark, Providers } from '../types/domain';
+import { Clear, ProviderMark } from '../types/domain';
+import { BrowserContext } from './browser-context';
+import { HeadlessContext } from './headless-context';
 /**
  * `DOMContext` is an immutable class that represents the context of a DOM element.
  * It provides methods and properties to manipulate and interact with the DOM element.
@@ -8,145 +10,113 @@ import { ProviderMark, Providers } from '../types/domain';
  *
  * @public
  */
-export declare class DOMContext {
+export interface DOMContext {
     /**
-     * The `Document` instance associated with this context.
-     */
-    readonly document: Document;
-    /**
-     * The `Element` instance associated with this context.
-     */
-    readonly element: Element;
-    /**
-     * An optional `Node` instance that serves as a reference for this context.
-     */
-    readonly reference: Node | undefined;
-    /**
-     * The `Providers` instance associated with this context.
-     */
-    readonly providers: Providers;
-    /**
-     * A boolean value indicating whether this context is at the first level, meaning the outermost node in the generated
-     */
-    readonly isFirstLevel: boolean;
-    /**
-     * Creates a new `DOMContext` instance for the given `Element` and optional reference `Node`.
+     * Creates a new DOM element (eg: HTML or SVG) with the specified tag name and namespace and appends it to the current element.
      *
-     * @param element - The `Element` to create the `DOMContext` for.
-     * @param ref - An optional reference `Node` to associate with the `DOMContext`.
-     * @returns A new `DOMContext` instance.
+     * @param tagName - The tag name of the element to create.
+     * @param namespace - The namespace URI to create the element in, or `undefined` to create a standard HTML element.
+     * @returns The newly created element.
      */
-    static of(element: Element, ref?: Node | undefined): DOMContext;
+    makeChildElement(tagName: string, namespace: string | undefined): DOMContext;
     /**
-     * Constructs a new `DOMContext` instance.
-     *
-     * @param document - The `Document` instance associated with this context.
-     * @param element - The `Element` instance associated with this context.
-     * @param reference - An optional `Node` instance that serves as a reference for this context.
-     * @param providers - The `Providers` instance associated with this context.
-     * @param isFirstLevel - A boolean value indicating whether this context is at the first level, meaning the outermost node in the generated DOM.
+     * Creates a new text node with the specified text content and appends it to the current element.
+     * @param text - The text content for the new text node.
+     * @returns A new `DOMContext` with a reference to the new text node.
      */
-    constructor(
+    makeChildText(text: string): DOMContext;
     /**
-     * The `Document` instance associated with this context.
+     * Sets the text content of the current element.
+     * @param text - The text content to set.
      */
-    document: Document, 
+    setText(text: string): void;
     /**
-     * The `Element` instance associated with this context.
+     * Gets the text content of the current element or text node.
+     * @returns The text content of the current element or text node.
      */
-    element: Element, 
+    getText(): string;
     /**
-     * An optional `Node` instance that serves as a reference for this context.
+     * Creates a new `DOMContext` with a reference to a newly created text node.
+     * The text node is appended or inserted to the current `DOMContext`.
+     * The new `DOMContext` with the reference is returned.
      */
-    reference: Node | undefined, 
+    makeRef(): DOMContext;
     /**
-     * The `Providers` instance associated with this context.
+     * Creates a new `DOMContext` instance with a reference to a DOM element selected by the provided `selector`.
+     * @param selector - The CSS selector for the target DOM element.
+     * @returns A new `DOMContext` instance with a reference to the selected DOM element.
      */
-    providers: Providers, 
+    makePortal(selector: string): DOMContext;
     /**
-     * A boolean value indicating whether this context is at the first level, meaning the outermost node in the generated
+     * Returns a new DOMContext instance with the specified providers merged into
+     * the existing providers.
+     *
+     * @param providers - An object containing the providers to be merged into the existing providers.
+     * @returns A new DOMContext instance with the merged providers.
      */
-    isFirstLevel: boolean);
+    withProviders(providers: {
+        [K in ProviderMark<unknown>]: unknown;
+    }): DOMContext;
     /**
-     * Creates a new DOM element (eg: HTML or SVG) with the specified tag name and namespace.
+     * Retrieves a provider for the given provider mark.
      *
-     * @param tagName - The tag name of the element to create.
-     * @param namespace - The namespace URI to create the element in, or `undefined` to create a standard HTML element.
-     * @returns The newly created element.
+     * @param mark - The provider mark to retrieve the provider for.
+     * @returns The provider for the given mark.
+     * @throws Throws `ProviderNotFoundError` if the provider for the given mark is not found.
      */
-    readonly createElement: (tagName: string, namespace: string | undefined) => Element;
+    getProvider<T>(mark: ProviderMark<T>): T;
+    clear(removeTree: boolean): void;
     /**
-     * Creates a new text node with the specified text content.
-     * @param text - The text content for the new text node.
-     * @returns A new `Text` node with the specified text content.
+     * Adds an event listener to the element.
+     * @param event - The event to listen for.
+     * @param listener - The listener to call when the event occurs.
+     * @returns A function to remove the event listener.
      */
-    readonly createText: (text: string) => Text;
+    on<E>(event: string, listener: (event: E) => void): Clear;
     /**
-     * Creates a new `DOMContext` with a reference to a newly created text node.
-     * The text node is appended or inserted to the current `DOMContext`.
-     * The new `DOMContext` with the reference is returned.
+     * Adds classes to the element.
+     * @param tokens - The class names to add.
      */
-    readonly makeRef: () => DOMContext;
+    addClasses(tokens: string[]): void;
     /**
-     * Appends or inserts a child node to the element, depending on whether a reference node is provided.
-     *
-     * @param child - The child node to append or insert.
+     * Removes classes from the element.
+     * @param tokens - The class names to remove.
      */
-    readonly appendOrInsert: (child: Node) => void;
+    removeClasses(tokens: string[]): void;
     /**
-     * Creates a new `DOMContext` instance with the provided `document`.
-     *
-     * @param document - The `Document` to use for the `DOMContext`.
-     * @returns A new `DOMContext` instance.
+     * Gets the classes of the element.
+     * @returns The classes of the element.
      */
-    readonly withDocument: (document: Document) => DOMContext;
+    getClasses(): string[];
     /**
-     * Creates a new `DOMContext` instance with the provided `element`.
-     * @param element - The DOM element to use in the new `DOMContext` instance.
-     * @returns A new `DOMContext` instance with the provided `element`.
+     * Returns `true` if the context is a browser DOM context.
+     * @returns `true` if the context is a browser DOM context.
      */
-    readonly withElement: (element: Element) => DOMContext;
+    isBrowserDOM(): this is BrowserContext;
     /**
-     * Creates a new `DOMContext` instance with the `isFirstLevel` property set to `true`.
-     * @returns A new `DOMContext` instance with the `isFirstLevel` property set to `true`.
+     * Returns `true` if the context is a headless DOM context.
+     * @returns `true` if the context is a headless DOM context.
      */
-    readonly withFirstLevel: () => DOMContext;
+    isHeadlessDOM(): this is HeadlessContext;
     /**
-     * Creates a new `DOMContext` instance with the specified reference.
-     *
-     * @param reference - The optional `Text` node to use as the reference for the new `DOMContext`.
-     * @returns A new `DOMContext` instance with the specified reference.
+     * Sets the style of the element.
+     * @param name - The name of the style to set.
+     * @param value - The value of the style to set.
      */
-    readonly withReference: (reference: Text | undefined) => DOMContext;
-    /** Creates a new DOMContext with the provided provider value.
-     *
-     * @param mark - The provider mark to associate the value with.
-     * @param value - The value to set for the provider.
-     * @returns A new DOMContext with the updated providers.
-     */
-    readonly withProvider: <T>(mark: ProviderMark<T>, value: T) => DOMContext;
+    setStyle(name: string, value: string): void;
     /**
-     * Returns a new DOMContext instance with the specified providers merged into
-     * the existing providers.
-     *
-     * @param providers - An object containing the providers to be merged into the existing providers.
-     * @returns A new DOMContext instance with the merged providers.
+     * Gets the style of the element.
+     * @param name - The name of the style to get.
+     * @returns The value of the style.
      */
-    readonly withProviders: (providers: { [K in ProviderMark<unknown>]: unknown; }) => DOMContext;
+    getStyle(name: string): string;
     /**
-     * Retrieves a provider for the given provider mark.
-     *
-     * @param mark - The provider mark to retrieve the provider for.
-     * @returns The provider for the given mark.
-     * @throws Throws `ProviderNotFoundError` if the provider for the given mark is not found.
+     * Returns an object with methods to get and set the value of a property or attribute.
+     * @param name - The name of the property to create accessors for.
+     * @returns An object with methods to get and set the value of the property.
      */
-    readonly getProvider: <T>(mark: ProviderMark<T>) => T;
-}
-/**
- * Error thrown when a provider is not found.
- *
- * @public
- */
-export declare class ProviderNotFoundError extends Error {
-    constructor(mark: ProviderMark<unknown>);
+    makeAccessors(name: string): {
+        get(): unknown;
+        set(value: unknown): void;
+    };
 }

package/dom/dom-utils.d.ts

@@ -13,7 +13,7 @@ export declare const _removeDOMNode: (node: Node) => void;
  * @returns The `Element` for the given `node`.
  * @internal
  */
-export declare const _getSelfOrParentElement: (node: Node) => Element;
+export declare const _getSelfOrParentElement: (node: Node) => HTMLElement;
 /**
  * Determines if the given `Node` is an `Element`.
  *
@@ -21,4 +21,4 @@ export declare const _getSelfOrParentElement: (node: Node) => Element;
  * @returns `true` if the `node` is an `Element`, `false` otherwise.
  * @internal
  */
-export declare const _isElement: (node: Node) => node is Element;
+export declare const _isElement: (node: Node) => node is HTMLElement;

package/dom/errors.d.ts

@@ -0,0 +1,9 @@
+import { ProviderMark } from '../types/domain';
+/**
+ * Error thrown when a provider is not found.
+ *
+ * @public
+ */
+export declare class ProviderNotFoundError extends Error {
+    constructor(mark: ProviderMark<unknown>);
+}

package/dom/headless-context.d.ts

@@ -0,0 +1,103 @@
+import { Prop } from '../std/signal';
+import { ProviderMark, Clear, Providers } from '../types/domain';
+import { BrowserContext } from './browser-context';
+import { DOMContext } from './dom-context';
+declare abstract class HeadlessBase {
+    readonly parent: HeadlessBase | undefined;
+    readonly id: string;
+    private readonly properties;
+    readonly children: HeadlessNode[];
+    constructor(parent: HeadlessBase | undefined);
+    readonly isElement: () => this is HeadlessBase;
+    readonly isText: () => this is HeadlessText;
+    readonly getText: () => string;
+    readonly removeChild: (child: HeadlessNode) => void;
+    readonly remove: () => void;
+    abstract isPortal(): this is HeadlessPortal;
+    readonly getPortals: () => HeadlessPortal[];
+    readonly elements: () => HeadlessBase[];
+    abstract toHTML(): string;
+    readonly hasInnerHTML: () => boolean;
+    readonly getInnerHTML: () => string;
+    readonly getInnerText: () => string;
+    readonly hasInnerText: () => boolean;
+    readonly hasChildren: () => boolean;
+    readonly hasClasses: () => boolean;
+    readonly hasStyles: () => boolean;
+    readonly hasAttributes: () => boolean;
+    readonly hasHandlers: () => boolean;
+    readonly hasRenderableProperties: () => boolean;
+    readonly getById: (id: string) => HeadlessBase | undefined;
+    readonly trigger: <E>(event: string, detail: E) => void;
+    readonly click: () => void;
+    readonly on: <E>(event: string, listener: (event: E) => void) => Clear;
+    readonly addClasses: (tokens: string[]) => void;
+    readonly removeClasses: (tokens: string[]) => void;
+    readonly getClasses: () => string[];
+    readonly getAttributes: () => [string, unknown][];
+    readonly getVisibleAttributes: () => (["class", string[]] | ["style", string | Record<string, string>] | [string, string])[];
+    readonly setStyle: (name: string, value: string) => void;
+    readonly getStyle: (name: string) => string;
+    readonly getStyles: () => Record<string, string>;
+    readonly makeAccessors: (name: string) => {
+        get(): unknown;
+        set(value: unknown): void;
+    };
+}
+export declare class HeadlessElement extends HeadlessBase {
+    readonly tagName: string;
+    readonly namespace: string | undefined;
+    constructor(tagName: string, namespace: string | undefined, parent: HeadlessBase | undefined);
+    readonly isPortal: () => this is HeadlessPortal;
+    readonly toHTML: () => string;
+}
+export declare class HeadlessPortal extends HeadlessBase {
+    readonly selector: string;
+    constructor(selector: string, parent: HeadlessBase | undefined);
+    readonly isPortal: () => this is HeadlessPortal;
+    readonly toHTML: () => string;
+    readonly contentToHTML: () => string;
+}
+export declare class HeadlessText {
+    text: string;
+    readonly id: string;
+    constructor(text: string);
+    readonly isElement: () => this is HeadlessElement;
+    readonly isText: () => this is HeadlessText;
+    readonly getText: () => string;
+    readonly toHTML: () => string;
+}
+export type HeadlessNode = HeadlessElement | HeadlessPortal | HeadlessText;
+export interface HeadlessContainer {
+    currentURL: Prop<string>;
+}
+export declare class HeadlessContext implements DOMContext {
+    readonly element: HeadlessBase;
+    readonly reference: HeadlessNode | undefined;
+    readonly container: HeadlessContainer;
+    readonly providers: Providers;
+    constructor(element: HeadlessBase, reference: HeadlessNode | undefined, container: HeadlessContainer, providers: Providers);
+    readonly appendOrInsert: (element: HeadlessNode) => void;
+    readonly makeChildElement: (tagName: string, namespace: string | undefined) => DOMContext;
+    readonly makeChildText: (text: string) => DOMContext;
+    readonly setText: (text: string) => void;
+    readonly getText: () => string;
+    readonly makeRef: () => DOMContext;
+    readonly makePortal: (selector: string) => DOMContext;
+    readonly withProviders: (providers: { [K in ProviderMark<unknown>]: unknown; }) => DOMContext;
+    readonly getProvider: <T>(mark: ProviderMark<T>) => T;
+    readonly clear: (removeTree: boolean) => void;
+    readonly on: <E>(event: string, listener: (event: E) => void) => Clear;
+    readonly addClasses: (tokens: string[]) => void;
+    readonly removeClasses: (tokens: string[]) => void;
+    readonly getClasses: () => string[];
+    readonly isBrowserDOM: () => this is BrowserContext;
+    readonly isHeadlessDOM: () => this is HeadlessContext;
+    readonly setStyle: (name: string, value: string) => void;
+    readonly getStyle: (name: string) => string;
+    readonly makeAccessors: (name: string) => {
+        get(): unknown;
+        set(value: unknown): void;
+    };
+}
+export {};