revojs 0.0.18 → 0.0.20

package/dist/html/index.d.ts

@@ -1,4 +1,4 @@
-import { type HtmlAttributes } from "../jsx";
+import { type EventListener, type HtmlAttributes } from "../jsx";
 import { type Descriptor, Hooks, Scope, type State, type Value } from "../signals";
 export type TypeOf<T> = {
     (): T;
@@ -11,7 +11,7 @@ export type Template = {
     children: Array<Slot>;
 };
 export type EventInput<T extends Events> = {
-    [K in keyof T]?: (event: Infer<T[K]["type"]> extends Event ? Infer<T[K]["type"]> : CustomEvent<Infer<T[K]["type"]>>) => void;
+    [K in keyof T]?: EventListener<Infer<T[K]["type"]> extends Event ? Infer<T[K]["type"]> : CustomEvent<Infer<T[K]["type"]>>>;
 };
 export type AttributeInput<T extends Attributes> = {
     [K in keyof T]?: Value<Infer<T[K]["type"]> | undefined>;
@@ -45,7 +45,7 @@ export interface ComponentOptions<TEvents extends Events, TAttributes extends At
 export interface Component<TEvents extends Events, TAttributes extends Attributes> {
     readonly scope: Scope;
     readonly hooks: Hooks;
-    readonly context: Map<symbol, unknown>;
+    readonly context: Map<string, unknown>;
     readonly events: EventOutput<TEvents>;
     readonly attributes: State<AttributeOutput<TAttributes>>;
     readonly shadowRoot: false | ShadowRootInit;
@@ -59,7 +59,7 @@ export interface ComponentConstructor<TEvents extends Events, TAttributes extend
     $name: string;
     $events: TEvents;
     $attributes: TAttributes;
-    new (input?: Input<TEvents, TAttributes>, context?: Map<symbol, unknown>, host?: CustomElement<TEvents, TAttributes>): Component<TEvents, TAttributes>;
+    new (input?: Input<TEvents, TAttributes>, context?: Map<string, unknown>, host?: CustomElement<TEvents, TAttributes>): Component<TEvents, TAttributes>;
 }
 export interface CustomElement<TEvents extends Events, TAttributes extends Attributes> extends HTMLElement {
     readonly component: Component<TEvents, TAttributes>;
@@ -71,7 +71,7 @@ export declare const isTemplate: (value: object) => value is Template;
 export declare const createElement: <TEvents extends Events, TAttributes extends Attributes>(input: string | Template | ComponentConstructor<TEvents, TAttributes>, attributes?: AttributeInput<TAttributes>, ...children: Array<Slot>) => Slot;
 export declare const toString: (slot: Slot) => string;
 export declare const toFragment: (nodes: Array<Node>) => DocumentFragment;
-export declare const renderToString: (slot: Slot, context: Map<symbol, unknown>) => Promise<string>;
+export declare const renderToString: (slot: Slot, context: Map<string, unknown>) => Promise<string>;
 export declare const renderToNode: (scope: Scope, slot: Slot) => Promise<Node>;
 export declare const defineComponent: <TEvents extends Events = {}, TAttributes extends Attributes = {}>(options: ComponentOptions<TEvents, TAttributes>) => ComponentConstructor<TEvents, TAttributes>;
 export declare const toCustomElement: <TEvents extends Events = {}, TAttributes extends Attributes = {}>(component: ComponentConstructor<TEvents, TAttributes>) => CustomElementConstructor<TEvents, TAttributes>;

package/dist/index.js

@@ -112,16 +112,16 @@ var Hooks = class {
 	constructor() {
 		this.hooks = new Map();
 	}
-	on = (scope, input, invoke) => {
+	on(scope, input, invoke) {
 		const invokes = this.hooks.get(input) ?? new Set();
 		invokes.add(invoke);
 		this.hooks.set(input, invokes);
 		return scope.dispose.push(() => invokes.delete(invoke));
-	};
-	dispatch = (input, value) => {
+	}
+	dispatch(input, value) {
 		const invokes = this.hooks.get(input);
 		if (invokes) for (const invoke of invokes) invoke(value);
-	};
+	}
 };
 var Scope = class {
 	dispose;
@@ -197,11 +197,11 @@ function fromValue(value) {
 	if (value instanceof Function) return fromValue(value());
 	return value;
 }
-function defineHook() {
-	return Symbol();
+function defineHook(key) {
+	return key;
 }
-function defineContext() {
-	return Symbol();
+function defineContext(key) {
+	return key;
 }
 let activeCompute;
 const targets = new WeakMap();
@@ -321,12 +321,20 @@ const renderToNode = async (scope, slot) => {
 				const element = document.createElementNS(namespace(slot.tag), slot.tag);
 				for (const name in slot.attributes) {
 					const value = slot.attributes[name];
-					if (value) if (name.startsWith("on") && typeof value === "function") {
+					if (name.startsWith("on")) {
 						const event = name.substring(2).toLowerCase();
 						const controller = new AbortController();
-						element.addEventListener(event, value, { signal: controller.signal });
+						element.addEventListener(event, (event$1) => {
+							const invoke = value;
+							if (Array.isArray(invoke)) for (const target of invoke) target?.(event$1);
+							else invoke?.(event$1);
+						}, { signal: controller.signal });
 						scope.dispose.push(() => controller.abort());
-					} else createCompute(scope, () => element.setAttribute(name, toString(value)));
+					} else createCompute(scope, () => {
+						const set = toString(value);
+						if (set === "" || set === "false") return element.removeAttribute(name);
+						return element.setAttribute(name, set);
+					});
 				}
 				element.replaceChildren(await renderToNode(scope, slot.children));
 				return element;
@@ -384,7 +392,7 @@ const toCustomElement = (component) => {
 			this.component = new component(void 0, void 0, this);
 		}
 		async connectedCallback() {
-			const shadow = this.component.shadowRoot ? this.attachShadow(this.component.shadowRoot) : this;
+			const rootNode = this.component.shadowRoot ? this.attachShadow(this.component.shadowRoot) : this;
 			const parentNode = getCustomElement(this.parentNode);
 			for (const [name, event] of Object.entries(component.$events)) Reflect.set(this.component.events, name, (value) => {
 				if (value instanceof Event) return;
@@ -394,7 +402,7 @@ const toCustomElement = (component) => {
 				}));
 			}, this.component.events);
 			if (parentNode) for (const [name, value] of parentNode.component.context) this.component.context.set(name, value);
-			shadow.replaceChildren(await renderToNode(this.component.scope, await this.component.setup()));
+			rootNode.replaceChildren(await renderToNode(this.component.scope, await this.component.setup()));
 			this.component.hooks.dispatch(MOUNTED_HOOK, this);
 		}
 		attributeChangedCallback(name, oldValue, value) {
@@ -454,7 +462,7 @@ const isServer = () => typeof window === "undefined";
 const preventDefault = (event) => event.preventDefault();
 const stopPropagation = (event) => event.stopPropagation();
 const stopImmediatePropagation = (event) => event.stopImmediatePropagation();
-const MOUNTED_HOOK = defineHook();
+const MOUNTED_HOOK = defineHook("MOUNTED_HOOK");
 const components = new Map();
 
 //#endregion
@@ -740,7 +748,7 @@ const createRuntime = async () => {
 		}
 	};
 };
-const RUNTIME_CONTEXT = defineContext();
+const RUNTIME_CONTEXT = defineContext("RUNTIME_CONTEXT");
 
 //#endregion
 //#region src/router/index.tsx

package/dist/jsx/index.d.ts

@@ -1,127 +1,128 @@
 import { type Slot } from "../html";
+export type EventListener<T extends Event> = ((event: T) => void) | Array<(event: T) => void>;
 export type EventAttributes = {
-    onScroll?: (event: Event) => void;
-    onScrollCapture?: (event: Event) => void;
-    onScrollEnd?: (event: Event) => void;
-    onScrollEndCapture?: (event: Event) => void;
-    onWheel?: (event: WheelEvent) => void;
-    onWheelCapture?: (event: WheelEvent) => void;
-    onAnimationCancel?: (event: AnimationEvent) => void;
-    onAnimationCancelCapture?: (event: AnimationEvent) => void;
-    onAnimationEnd?: (event: AnimationEvent) => void;
-    onAnimationEndCapture?: (event: AnimationEvent) => void;
-    onAnimationIteration?: (event: AnimationEvent) => void;
-    onAnimationIterationCapture?: (event: AnimationEvent) => void;
-    onAnimationStart?: (event: AnimationEvent) => void;
-    onAnimationStartCapture?: (event: AnimationEvent) => void;
-    onCopy?: (event: ClipboardEvent) => void;
-    onCopyCapture?: (event: ClipboardEvent) => void;
-    onCut?: (event: ClipboardEvent) => void;
-    onCutCapture?: (event: ClipboardEvent) => void;
-    onPaste?: (event: ClipboardEvent) => void;
-    onPasteCapture?: (event: ClipboardEvent) => void;
-    onCompositionEnd?: (event: CompositionEvent) => void;
-    onCompositionEndCapture?: (event: CompositionEvent) => void;
-    onCompositionStart?: (event: CompositionEvent) => void;
-    onCompositionStartCapture?: (event: CompositionEvent) => void;
-    onCompositionUpdate?: (event: CompositionEvent) => void;
-    onCompositionUpdateCapture?: (event: CompositionEvent) => void;
-    onBlur?: (event: FocusEvent) => void;
-    onBlurCapture?: (event: FocusEvent) => void;
-    onFocus?: (event: FocusEvent) => void;
-    onFocusCapture?: (event: FocusEvent) => void;
-    onFocusIn?: (event: FocusEvent) => void;
-    onFocusInCapture?: (event: FocusEvent) => void;
-    onFocusOut?: (event: FocusEvent) => void;
-    onFocusOutCapture?: (event: FocusEvent) => void;
-    onFullscreenChange?: (event: Event) => void;
-    onFullscreenChangeCapture?: (event: Event) => void;
-    onFullscreenError?: (event: Event) => void;
-    onFullscreenErrorCapture?: (event: Event) => void;
-    onKeyDown?: (event: KeyboardEvent) => void;
-    onKeyDownCapture?: (event: KeyboardEvent) => void;
-    onKeyPress?: (event: KeyboardEvent) => void;
-    onKeyPressCapture?: (event: KeyboardEvent) => void;
-    onKeyUp?: (event: KeyboardEvent) => void;
-    onKeyUpCapture?: (event: KeyboardEvent) => void;
-    onAuxClick?: (event: MouseEvent) => void;
-    onAuxClickCapture?: (event: MouseEvent) => void;
-    onClick?: (event: MouseEvent) => void;
-    onClickCapture?: (event: MouseEvent) => void;
-    onContextMenu?: (event: MouseEvent) => void;
-    onContextMenuCapture?: (event: MouseEvent) => void;
-    onDoubleClick?: (event: MouseEvent) => void;
-    onDoubleClickCapture?: (event: MouseEvent) => void;
-    onMouseDown?: (event: MouseEvent) => void;
-    onMouseDownCapture?: (event: MouseEvent) => void;
-    onMouseEnter?: (event: MouseEvent) => void;
-    onMouseEnterCapture?: (event: MouseEvent) => void;
-    onMouseLeave?: (event: MouseEvent) => void;
-    onMouseLeaveCapture?: (event: MouseEvent) => void;
-    onMouseMove?: (event: MouseEvent) => void;
-    onMouseMoveCapture?: (event: MouseEvent) => void;
-    onMouseOut?: (event: MouseEvent) => void;
-    onMouseOutCapture?: (event: MouseEvent) => void;
-    onMouseOver?: (event: MouseEvent) => void;
-    onMouseOverCapture?: (event: MouseEvent) => void;
-    onMouseUp?: (event: MouseEvent) => void;
-    onMouseUpCapture?: (event: MouseEvent) => void;
-    onMouseWheel?: (event: WheelEvent) => void;
-    onMouseWheelCapture?: (event: WheelEvent) => void;
-    onGotPointerCapture?: (event: PointerEvent) => void;
-    onGotPointerCaptureCapture?: (event: PointerEvent) => void;
-    onLostPointerCapture?: (event: PointerEvent) => void;
-    onLostPointerCaptureCapture?: (event: PointerEvent) => void;
-    onPointerCancel?: (event: PointerEvent) => void;
-    onPointerCancelCapture?: (event: PointerEvent) => void;
-    onPointerDown?: (event: PointerEvent) => void;
-    onPointerDownCapture?: (event: PointerEvent) => void;
-    onPointerEnter?: (event: PointerEvent) => void;
-    onPointerEnterCapture?: (event: PointerEvent) => void;
-    onPointerLeave?: (event: PointerEvent) => void;
-    onPointerLeaveCapture?: (event: PointerEvent) => void;
-    onPointerMove?: (event: PointerEvent) => void;
-    onPointerMoveCapture?: (event: PointerEvent) => void;
-    onPointerOut?: (event: PointerEvent) => void;
-    onPointerOutCapture?: (event: PointerEvent) => void;
-    onPointerOver?: (event: PointerEvent) => void;
-    onPointerOverCapture?: (event: PointerEvent) => void;
-    onPointerUp?: (event: PointerEvent) => void;
-    onPointerUpCapture?: (event: PointerEvent) => void;
-    onTouchCancel?: (event: TouchEvent) => void;
-    onTouchCancelCapture?: (event: TouchEvent) => void;
-    onTouchEnd?: (event: TouchEvent) => void;
-    onTouchEndCapture?: (event: TouchEvent) => void;
-    onTouchMove?: (event: TouchEvent) => void;
-    onTouchMoveCapture?: (event: TouchEvent) => void;
-    onTouchStart?: (event: TouchEvent) => void;
-    onTouchStartCapture?: (event: TouchEvent) => void;
-    onTransitionCancel?: (event: TransitionEvent) => void;
-    onTransitionCancelCapture?: (event: TransitionEvent) => void;
-    onTransitionEnd?: (event: TransitionEvent) => void;
-    onTransitionEndCapture?: (event: TransitionEvent) => void;
-    onTransitionRun?: (event: TransitionEvent) => void;
-    onTransitionRunCapture?: (event: TransitionEvent) => void;
-    onTransitionStart?: (event: TransitionEvent) => void;
-    onTransitionStartCapture?: (event: TransitionEvent) => void;
-    onFormData?: (event: FormDataEvent) => void;
-    onFormDataCapture?: (event: FormDataEvent) => void;
-    onReset?: (event: Event) => void;
-    onResetCapture?: (event: Event) => void;
-    onSubmit?: (event: Event) => void;
-    onSubmitCapture?: (event: Event) => void;
-    onInvalid?: (event: Event) => void;
-    onInvalidCapture?: (event: Event) => void;
-    onSelect?: (event: Event) => void;
-    onSelectCapture?: (event: Event) => void;
-    onSelectChange?: (event: Event) => void;
-    onSelectChangeCapture?: (event: Event) => void;
-    onInput?: (event: InputEvent) => void;
-    onInputCapture?: (event: InputEvent) => void;
-    onBeforeInput?: (event: InputEvent) => void;
-    onBeforeInputCapture?: (event: InputEvent) => void;
-    onChange?: (event: Event) => void;
-    onChangeCapture?: (event: Event) => void;
+    onScroll?: EventListener<Event>;
+    onScrollCapture?: EventListener<Event>;
+    onScrollEnd?: EventListener<Event>;
+    onScrollEndCapture?: EventListener<Event>;
+    onWheel?: EventListener<WheelEvent>;
+    onWheelCapture?: EventListener<WheelEvent>;
+    onAnimationCancel?: EventListener<AnimationEvent>;
+    onAnimationCancelCapture?: EventListener<AnimationEvent>;
+    onAnimationEnd?: EventListener<AnimationEvent>;
+    onAnimationEndCapture?: EventListener<AnimationEvent>;
+    onAnimationIteration?: EventListener<AnimationEvent>;
+    onAnimationIterationCapture?: EventListener<AnimationEvent>;
+    onAnimationStart?: EventListener<AnimationEvent>;
+    onAnimationStartCapture?: EventListener<AnimationEvent>;
+    onCopy?: EventListener<ClipboardEvent>;
+    onCopyCapture?: EventListener<ClipboardEvent>;
+    onCut?: EventListener<ClipboardEvent>;
+    onCutCapture?: EventListener<ClipboardEvent>;
+    onPaste?: EventListener<ClipboardEvent>;
+    onPasteCapture?: EventListener<ClipboardEvent>;
+    onCompositionEnd?: EventListener<CompositionEvent>;
+    onCompositionEndCapture?: EventListener<CompositionEvent>;
+    onCompositionStart?: EventListener<CompositionEvent>;
+    onCompositionStartCapture?: EventListener<CompositionEvent>;
+    onCompositionUpdate?: EventListener<CompositionEvent>;
+    onCompositionUpdateCapture?: EventListener<CompositionEvent>;
+    onBlur?: EventListener<FocusEvent>;
+    onBlurCapture?: EventListener<FocusEvent>;
+    onFocus?: EventListener<FocusEvent>;
+    onFocusCapture?: EventListener<FocusEvent>;
+    onFocusIn?: EventListener<FocusEvent>;
+    onFocusInCapture?: EventListener<FocusEvent>;
+    onFocusOut?: EventListener<FocusEvent>;
+    onFocusOutCapture?: EventListener<FocusEvent>;
+    onFullscreenChange?: EventListener<Event>;
+    onFullscreenChangeCapture?: EventListener<Event>;
+    onFullscreenError?: EventListener<Event>;
+    onFullscreenErrorCapture?: EventListener<Event>;
+    onKeyDown?: EventListener<KeyboardEvent>;
+    onKeyDownCapture?: EventListener<KeyboardEvent>;
+    onKeyPress?: EventListener<KeyboardEvent>;
+    onKeyPressCapture?: EventListener<KeyboardEvent>;
+    onKeyUp?: EventListener<KeyboardEvent>;
+    onKeyUpCapture?: EventListener<KeyboardEvent>;
+    onAuxClick?: EventListener<MouseEvent>;
+    onAuxClickCapture?: EventListener<MouseEvent>;
+    onClick?: EventListener<MouseEvent>;
+    onClickCapture?: EventListener<MouseEvent>;
+    onContextMenu?: EventListener<MouseEvent>;
+    onContextMenuCapture?: EventListener<MouseEvent>;
+    onDoubleClick?: EventListener<MouseEvent>;
+    onDoubleClickCapture?: EventListener<MouseEvent>;
+    onMouseDown?: EventListener<MouseEvent>;
+    onMouseDownCapture?: EventListener<MouseEvent>;
+    onMouseEnter?: EventListener<MouseEvent>;
+    onMouseEnterCapture?: EventListener<MouseEvent>;
+    onMouseLeave?: EventListener<MouseEvent>;
+    onMouseLeaveCapture?: EventListener<MouseEvent>;
+    onMouseMove?: EventListener<MouseEvent>;
+    onMouseMoveCapture?: EventListener<MouseEvent>;
+    onMouseOut?: EventListener<MouseEvent>;
+    onMouseOutCapture?: EventListener<MouseEvent>;
+    onMouseOver?: EventListener<MouseEvent>;
+    onMouseOverCapture?: EventListener<MouseEvent>;
+    onMouseUp?: EventListener<MouseEvent>;
+    onMouseUpCapture?: EventListener<MouseEvent>;
+    onMouseWheel?: EventListener<WheelEvent>;
+    onMouseWheelCapture?: EventListener<WheelEvent>;
+    onGotPointerCapture?: EventListener<PointerEvent>;
+    onGotPointerCaptureCapture?: EventListener<PointerEvent>;
+    onLostPointerCapture?: EventListener<PointerEvent>;
+    onLostPointerCaptureCapture?: EventListener<PointerEvent>;
+    onPointerCancel?: EventListener<PointerEvent>;
+    onPointerCancelCapture?: EventListener<PointerEvent>;
+    onPointerDown?: EventListener<PointerEvent>;
+    onPointerDownCapture?: EventListener<PointerEvent>;
+    onPointerEnter?: EventListener<PointerEvent>;
+    onPointerEnterCapture?: EventListener<PointerEvent>;
+    onPointerLeave?: EventListener<PointerEvent>;
+    onPointerLeaveCapture?: EventListener<PointerEvent>;
+    onPointerMove?: EventListener<PointerEvent>;
+    onPointerMoveCapture?: EventListener<PointerEvent>;
+    onPointerOut?: EventListener<PointerEvent>;
+    onPointerOutCapture?: EventListener<PointerEvent>;
+    onPointerOver?: EventListener<PointerEvent>;
+    onPointerOverCapture?: EventListener<PointerEvent>;
+    onPointerUp?: EventListener<PointerEvent>;
+    onPointerUpCapture?: EventListener<PointerEvent>;
+    onTouchCancel?: EventListener<TouchEvent>;
+    onTouchCancelCapture?: EventListener<TouchEvent>;
+    onTouchEnd?: EventListener<TouchEvent>;
+    onTouchEndCapture?: EventListener<TouchEvent>;
+    onTouchMove?: EventListener<TouchEvent>;
+    onTouchMoveCapture?: EventListener<TouchEvent>;
+    onTouchStart?: EventListener<TouchEvent>;
+    onTouchStartCapture?: EventListener<TouchEvent>;
+    onTransitionCancel?: EventListener<TransitionEvent>;
+    onTransitionCancelCapture?: EventListener<TransitionEvent>;
+    onTransitionEnd?: EventListener<TransitionEvent>;
+    onTransitionEndCapture?: EventListener<TransitionEvent>;
+    onTransitionRun?: EventListener<TransitionEvent>;
+    onTransitionRunCapture?: EventListener<TransitionEvent>;
+    onTransitionStart?: EventListener<TransitionEvent>;
+    onTransitionStartCapture?: EventListener<TransitionEvent>;
+    onFormData?: EventListener<FormDataEvent>;
+    onFormDataCapture?: EventListener<FormDataEvent>;
+    onReset?: EventListener<Event>;
+    onResetCapture?: EventListener<Event>;
+    onSubmit?: EventListener<Event>;
+    onSubmitCapture?: EventListener<Event>;
+    onInvalid?: EventListener<Event>;
+    onInvalidCapture?: EventListener<Event>;
+    onSelect?: EventListener<Event>;
+    onSelectCapture?: EventListener<Event>;
+    onSelectChange?: EventListener<Event>;
+    onSelectChangeCapture?: EventListener<Event>;
+    onInput?: EventListener<InputEvent>;
+    onInputCapture?: EventListener<InputEvent>;
+    onBeforeInput?: EventListener<InputEvent>;
+    onBeforeInputCapture?: EventListener<InputEvent>;
+    onChange?: EventListener<Event>;
+    onChangeCapture?: EventListener<Event>;
 };
 export type HtmlTags = Record<string, HtmlAttributes & EventAttributes>;
 export type HtmlAttributes = Record<string, unknown>;

package/dist/jsx/index.js

@@ -1,7 +1,7 @@
 
 //#region src/signals/index.ts
-function defineHook() {
-	return Symbol();
+function defineHook(key) {
+	return key;
 }
 
 //#endregion
@@ -14,7 +14,7 @@ const createElement = (input, attributes, ...children) => {
 		children
 	};
 };
-const MOUNTED_HOOK = defineHook();
+const MOUNTED_HOOK = defineHook("MOUNTED_HOOK");
 
 //#endregion
 //#region src/jsx/index.ts

package/dist/signals/index.d.ts

@@ -1,16 +1,16 @@
 declare const descriptor: unique symbol;
 export type Value<T> = T | (() => Value<T>);
-export type Descriptor<T> = symbol & {
+export type Descriptor<T> = string & {
     [descriptor]: T;
 };
 export interface State<T> {
     value: T;
 }
 export declare class Hooks {
-    readonly hooks: Map<symbol, Set<(value: any) => unknown>>;
+    readonly hooks: Map<string, Set<(value: any) => unknown>>;
     constructor();
-    on: <T>(scope: Scope, input: Descriptor<T>, invoke: (value: T) => unknown) => number;
-    dispatch: <T>(input: Descriptor<T>, value: T) => void;
+    on<T>(scope: Scope, input: Descriptor<T>, invoke: (value: T) => unknown): number;
+    dispatch<T>(input: Descriptor<T>, value: T): void;
 }
 export declare class Scope {
     readonly dispose: Array<(scope: Scope) => void>;
@@ -32,8 +32,8 @@ export declare function createState<T>(value: T): State<T>;
 export declare function createCompute<T>(scope: Scope, invoke: (scope: Scope) => T): T;
 export declare function createMemo<T>(scope: Scope, invoke: () => T): State<T>;
 export declare function fromValue<T>(value: Value<T>): T;
-export declare function defineHook<T>(): Descriptor<T>;
-export declare function defineContext<T>(): Descriptor<T>;
+export declare function defineHook<T>(key: string): Descriptor<T>;
+export declare function defineContext<T>(key: string): Descriptor<T>;
 export declare let activeCompute: Compute | undefined;
 export declare const targets: WeakMap<object, Map<string | symbol, Set<Compute<void>>>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "revojs",
-    "version": "0.0.18",
+    "version": "0.0.20",
     "type": "module",
     "repository": "coverbase/revojs",
     "license": "MIT",