dom-helpers

const _default: {
    addEventListener: typeof addEventListener;
    removeEventListener: typeof removeEventListener;
    triggerEvent: typeof triggerEvent;
    animate: typeof animate;
    filter: typeof filter;
    listen: typeof listen;
    style: typeof style;
    getComputedStyle: typeof getComputedStyle;
    attribute: typeof attribute;
    activeElement: typeof activeElement;
    ownerDocument: typeof ownerDocument;
    ownerWindow: typeof ownerWindow;
    requestAnimationFrame: typeof globalThis.requestAnimationFrame;
    cancelAnimationFrame: (id: number) => void;
    matches: typeof matches;
    height: typeof height;
    width: typeof width;
    offset: typeof offset;
    offsetParent: typeof offsetParent;
    position: typeof position;
    contains: typeof contains;
    scrollbarSize: typeof scrollbarSize;
    scrollLeft: { (node: Element): number; (node: Element, val: number): undefined };
    scrollParent: typeof scrollParent;
    scrollTo: typeof scrollTo;
    scrollTop: { (node: Element): number; (node: Element, val: number): undefined };
    querySelectorAll: typeof querySelectorAll;
    closest: typeof closest;
    addClass: typeof addClass;
    removeClass: typeof removeClass;
    hasClass: typeof hasClass;
    toggleClass: typeof toggleClass;
    transitionEnd: typeof transitionEnd;
    childNodes: typeof childNodes;
    childElements: typeof childElements;
    nextUntil: typeof nextUntil;
    parents: typeof parents;
    siblings: typeof siblings;
    clear: typeof clear;
    insertAfter: typeof insertAfter;
    isInput: typeof isInput;
    isVisible: typeof isVisible;
    prepend: typeof prepend;
    remove: typeof remove;
    text: typeof text;
};

const requestAnimationFrame: (callback: FrameRequestCallback) => number;

const scrollLeft: {
    (node: Element): number;
    (node: Element, val: number): undefined;
};

const scrollTop: {
    (node: Element): number;
    (node: Element, val: number): undefined;
};

activeElement: (doc?: Document) => Element | null;

addClass: (element: Element | SVGElement, className: string) => void;

addEventListener: <K extends keyof HTMLElementEventMap>(
    node: HTMLElement,
    eventName: K,
    handler: TaggedEventHandler<K>,
    options?: boolean | AddEventListenerOptions
) => void;

animate: {
    (options: Options): Cancel;
    (node: HTMLElement, properties: AnimateProperties, duration: number): Cancel;
    (
        node: HTMLElement,
        properties: AnimateProperties,
        duration: number,
        callback: EventHandler<'transitionend'>
    ): Cancel;
    (
        node: HTMLElement,
        properties: AnimateProperties,
        duration: number,
        easing: string,
        callback: EventHandler<'transitionend'>
    ): Cancel;
};

attribute: (
    node: Element | null,
    attr: string,
    val?: string | boolean | null
) => string | null | undefined;

cancelAnimationFrame: (id: number) => void;

childElements: (node: Element | null) => Element[];

childNodes: (node: Element | null) => Node[];

clear: (node: Node | null) => Node | null;

closest: (node: Element, selector: string, stopAt?: Element) => Element | null;

contains: (context: Element, node: Element) => boolean | undefined;

filter: <K extends keyof HTMLElementEventMap>(
    selector: string,
    handler: EventHandler<K>
) => EventHandler<K>;

getComputedStyle: (
    node: HTMLElement,
    psuedoElement?: string
) => CSSStyleDeclaration;

hasClass: (element: Element | SVGElement, className: string) => boolean;

height: (node: HTMLElement, client?: boolean) => number;

insertAfter: (node: Node | null, refNode: Node | null) => Node | null;

isInput: (node: Element | null) => boolean;

isVisible: (node: HTMLElement | null) => boolean;

listen: <K extends keyof HTMLElementEventMap>(
    node: HTMLElement,
    eventName: K,
    handler: EventHandler<K>,
    options?: boolean | AddEventListenerOptions
) => () => void;

matches: (node: Element, selector: string) => boolean;

nextUntil: (node: Element | null, selector: string) => Element[];

offset: (node: HTMLElement) => {
    top: number;
    left: number;
    height: number;
    width: number;
};

offsetParent: (node: HTMLElement) => HTMLElement;

ownerDocument: (node?: Element) => Document;

ownerWindow: (node?: Element) => Window;

parents: (node: Element | null) => Element[];

position: (
    node: HTMLElement,
    offsetParent?: HTMLElement
) => { top: number; left: number; height: number; width: number };

prepend: (node: Element | null, parent: Element | null) => Element | null;

querySelectorAll: (
    element: HTMLElement | Document,
    selector: string
) => HTMLElement[];

remove: (node: Node | null) => Node | null;

removeClass: (element: Element | SVGElement, className: string) => void;

removeEventListener: <K extends keyof HTMLElementEventMap>(
    node: HTMLElement,
    eventName: K,
    handler: TaggedEventHandler<K>,
    options?: boolean | EventListenerOptions
) => void;

scrollbarSize: (recalc?: boolean) => number;

scrollParent: (
    element: HTMLElement,
    firstPossible?: boolean
) => Document | HTMLElement;

scrollTo: (
    selected: HTMLElement,
    scrollParent?: HTMLElement
) => (() => void) | undefined;

siblings: (node: Element | null) => Element[];

style: {
    (node: HTMLElement, property: Partial<Record<Property, string>>): void;
    <T extends string | number | symbol>(
        node: HTMLElement,
        property: T
    ): CSS.PropertiesHyphen;
    <T extends string | number | symbol>(
        node: HTMLElement,
        property: T
    ): CSS.Properties;
};

text: (
    node: HTMLElement | null,
    trim?: boolean,
    singleSpaces?: boolean
) => string;

toggleClass: (element: Element | SVGElement, className: string) => void;

transitionEnd: (
    element: HTMLElement,
    handler: Listener,
    duration?: number | null,
    padding?: number
) => () => void;

triggerEvent: <K extends keyof HTMLElementEventMap>(
    node: HTMLElement | null,
    eventName: K,
    bubbles?: boolean,
    cancelable?: boolean
) => void;

width: (node: HTMLElement, client?: boolean) => number;