@universityofmaryland/web-model-library 1.0.7 → 1.1.0

package/dist/utilities/debug.d.ts

@@ -0,0 +1,365 @@
+declare global {
+    interface Window {
+        __UMD_DEV__?: boolean;
+    }
+}
+export declare function isDev(): boolean;
+export interface Logger {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    group: (...args: unknown[]) => void;
+    groupEnd: () => void;
+}
+export declare function createLogger(componentName: string): Logger;
+type Constructor<T = HTMLElement> = new (...args: any[]) => T;
+declare const debugLoggerKey: unique symbol;
+export declare function withLifecycleDebug<T extends Constructor>(Base: T): {
+    new (...args: any[]): {
+        connectedCallback(): void;
+        disconnectedCallback(): void;
+        attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null): void;
+        [debugLoggerKey]: Logger;
+        accessKey: string;
+        readonly accessKeyLabel: string;
+        autocapitalize: string;
+        dir: string;
+        draggable: boolean;
+        hidden: boolean;
+        inert: boolean;
+        innerText: string;
+        lang: string;
+        readonly offsetHeight: number;
+        readonly offsetLeft: number;
+        readonly offsetParent: Element | null;
+        readonly offsetTop: number;
+        readonly offsetWidth: number;
+        outerText: string;
+        popover: string | null;
+        spellcheck: boolean;
+        title: string;
+        translate: boolean;
+        writingSuggestions: string;
+        attachInternals(): ElementInternals;
+        click(): void;
+        hidePopover(): void;
+        showPopover(): void;
+        togglePopover(options?: boolean): boolean;
+        addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        readonly attributes: NamedNodeMap;
+        get classList(): DOMTokenList;
+        set classList(value: string);
+        className: string;
+        readonly clientHeight: number;
+        readonly clientLeft: number;
+        readonly clientTop: number;
+        readonly clientWidth: number;
+        readonly currentCSSZoom: number;
+        id: string;
+        innerHTML: string;
+        readonly localName: string;
+        readonly namespaceURI: string | null;
+        onfullscreenchange: ((this: Element, ev: Event) => any) | null;
+        onfullscreenerror: ((this: Element, ev: Event) => any) | null;
+        outerHTML: string;
+        readonly ownerDocument: Document;
+        get part(): DOMTokenList;
+        set part(value: string);
+        readonly prefix: string | null;
+        readonly scrollHeight: number;
+        scrollLeft: number;
+        scrollTop: number;
+        readonly scrollWidth: number;
+        readonly shadowRoot: ShadowRoot | null;
+        slot: string;
+        readonly tagName: string;
+        attachShadow(init: ShadowRootInit): ShadowRoot;
+        checkVisibility(options?: CheckVisibilityOptions): boolean;
+        closest<K extends keyof HTMLElementTagNameMap>(selector: K): HTMLElementTagNameMap[K] | null;
+        closest<K extends keyof SVGElementTagNameMap>(selector: K): SVGElementTagNameMap[K] | null;
+        closest<K extends keyof MathMLElementTagNameMap>(selector: K): MathMLElementTagNameMap[K] | null;
+        closest<E extends Element = Element>(selectors: string): E | null;
+        computedStyleMap(): StylePropertyMapReadOnly;
+        getAttribute(qualifiedName: string): string | null;
+        getAttributeNS(namespace: string | null, localName: string): string | null;
+        getAttributeNames(): string[];
+        getAttributeNode(qualifiedName: string): Attr | null;
+        getAttributeNodeNS(namespace: string | null, localName: string): Attr | null;
+        getBoundingClientRect(): DOMRect;
+        getClientRects(): DOMRectList;
+        getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
+        getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+        getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+        getElementsByTagName<K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+        getElementsByTagName<K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+        getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
+        getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+        getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<SVGElement>;
+        getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<MathMLElement>;
+        getElementsByTagNameNS(namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+        getHTML(options?: GetHTMLOptions): string;
+        hasAttribute(qualifiedName: string): boolean;
+        hasAttributeNS(namespace: string | null, localName: string): boolean;
+        hasAttributes(): boolean;
+        hasPointerCapture(pointerId: number): boolean;
+        insertAdjacentElement(where: InsertPosition, element: Element): Element | null;
+        insertAdjacentHTML(position: InsertPosition, string: string): void;
+        insertAdjacentText(where: InsertPosition, data: string): void;
+        matches(selectors: string): boolean;
+        releasePointerCapture(pointerId: number): void;
+        removeAttribute(qualifiedName: string): void;
+        removeAttributeNS(namespace: string | null, localName: string): void;
+        removeAttributeNode(attr: Attr): Attr;
+        requestFullscreen(options?: FullscreenOptions): Promise<void>;
+        requestPointerLock(options?: PointerLockOptions): Promise<void>;
+        scroll(options?: ScrollToOptions): void;
+        scroll(x: number, y: number): void;
+        scrollBy(options?: ScrollToOptions): void;
+        scrollBy(x: number, y: number): void;
+        scrollIntoView(arg?: boolean | ScrollIntoViewOptions): void;
+        scrollTo(options?: ScrollToOptions): void;
+        scrollTo(x: number, y: number): void;
+        setAttribute(qualifiedName: string, value: string): void;
+        setAttributeNS(namespace: string | null, qualifiedName: string, value: string): void;
+        setAttributeNode(attr: Attr): Attr | null;
+        setAttributeNodeNS(attr: Attr): Attr | null;
+        setHTMLUnsafe(html: string): void;
+        setPointerCapture(pointerId: number): void;
+        toggleAttribute(qualifiedName: string, force?: boolean): boolean;
+        webkitMatchesSelector(selectors: string): boolean;
+        readonly baseURI: string;
+        readonly childNodes: NodeListOf<ChildNode>;
+        readonly firstChild: ChildNode | null;
+        readonly isConnected: boolean;
+        readonly lastChild: ChildNode | null;
+        readonly nextSibling: ChildNode | null;
+        readonly nodeName: string;
+        readonly nodeType: number;
+        nodeValue: string | null;
+        readonly parentElement: HTMLElement | null;
+        readonly parentNode: ParentNode | null;
+        readonly previousSibling: ChildNode | null;
+        textContent: string | null;
+        appendChild<T_1 extends Node>(node: T_1): T_1;
+        cloneNode(subtree?: boolean): Node;
+        compareDocumentPosition(other: Node): number;
+        contains(other: Node | null): boolean;
+        getRootNode(options?: GetRootNodeOptions): Node;
+        hasChildNodes(): boolean;
+        insertBefore<T_1 extends Node>(node: T_1, child: Node | null): T_1;
+        isDefaultNamespace(namespace: string | null): boolean;
+        isEqualNode(otherNode: Node | null): boolean;
+        isSameNode(otherNode: Node | null): boolean;
+        lookupNamespaceURI(prefix: string | null): string | null;
+        lookupPrefix(namespace: string | null): string | null;
+        normalize(): void;
+        removeChild<T_1 extends Node>(child: T_1): T_1;
+        replaceChild<T_1 extends Node>(node: Node, child: T_1): T_1;
+        readonly ELEMENT_NODE: 1;
+        readonly ATTRIBUTE_NODE: 2;
+        readonly TEXT_NODE: 3;
+        readonly CDATA_SECTION_NODE: 4;
+        readonly ENTITY_REFERENCE_NODE: 5;
+        readonly ENTITY_NODE: 6;
+        readonly PROCESSING_INSTRUCTION_NODE: 7;
+        readonly COMMENT_NODE: 8;
+        readonly DOCUMENT_NODE: 9;
+        readonly DOCUMENT_TYPE_NODE: 10;
+        readonly DOCUMENT_FRAGMENT_NODE: 11;
+        readonly NOTATION_NODE: 12;
+        readonly DOCUMENT_POSITION_DISCONNECTED: 1;
+        readonly DOCUMENT_POSITION_PRECEDING: 2;
+        readonly DOCUMENT_POSITION_FOLLOWING: 4;
+        readonly DOCUMENT_POSITION_CONTAINS: 8;
+        readonly DOCUMENT_POSITION_CONTAINED_BY: 16;
+        readonly DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC: 32;
+        dispatchEvent(event: Event): boolean;
+        ariaAtomic: string | null;
+        ariaAutoComplete: string | null;
+        ariaBrailleLabel: string | null;
+        ariaBrailleRoleDescription: string | null;
+        ariaBusy: string | null;
+        ariaChecked: string | null;
+        ariaColCount: string | null;
+        ariaColIndex: string | null;
+        ariaColIndexText: string | null;
+        ariaColSpan: string | null;
+        ariaCurrent: string | null;
+        ariaDescription: string | null;
+        ariaDisabled: string | null;
+        ariaExpanded: string | null;
+        ariaHasPopup: string | null;
+        ariaHidden: string | null;
+        ariaInvalid: string | null;
+        ariaKeyShortcuts: string | null;
+        ariaLabel: string | null;
+        ariaLevel: string | null;
+        ariaLive: string | null;
+        ariaModal: string | null;
+        ariaMultiLine: string | null;
+        ariaMultiSelectable: string | null;
+        ariaOrientation: string | null;
+        ariaPlaceholder: string | null;
+        ariaPosInSet: string | null;
+        ariaPressed: string | null;
+        ariaReadOnly: string | null;
+        ariaRelevant: string | null;
+        ariaRequired: string | null;
+        ariaRoleDescription: string | null;
+        ariaRowCount: string | null;
+        ariaRowIndex: string | null;
+        ariaRowIndexText: string | null;
+        ariaRowSpan: string | null;
+        ariaSelected: string | null;
+        ariaSetSize: string | null;
+        ariaSort: string | null;
+        ariaValueMax: string | null;
+        ariaValueMin: string | null;
+        ariaValueNow: string | null;
+        ariaValueText: string | null;
+        role: string | null;
+        animate(keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): Animation;
+        getAnimations(options?: GetAnimationsOptions): Animation[];
+        after(...nodes: (Node | string)[]): void;
+        before(...nodes: (Node | string)[]): void;
+        remove(): void;
+        replaceWith(...nodes: (Node | string)[]): void;
+        readonly nextElementSibling: Element | null;
+        readonly previousElementSibling: Element | null;
+        readonly childElementCount: number;
+        readonly children: HTMLCollection;
+        readonly firstElementChild: Element | null;
+        readonly lastElementChild: Element | null;
+        append(...nodes: (Node | string)[]): void;
+        prepend(...nodes: (Node | string)[]): void;
+        querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+        querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+        querySelector<K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+        querySelector<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+        querySelector<E extends Element = Element>(selectors: string): E | null;
+        querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+        querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+        querySelectorAll<K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+        querySelectorAll<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+        querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
+        replaceChildren(...nodes: (Node | string)[]): void;
+        readonly assignedSlot: HTMLSlotElement | null;
+        readonly attributeStyleMap: StylePropertyMap;
+        get style(): CSSStyleDeclaration;
+        set style(cssText: string);
+        contentEditable: string;
+        enterKeyHint: string;
+        inputMode: string;
+        readonly isContentEditable: boolean;
+        onabort: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+        onanimationcancel: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationend: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationiteration: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onanimationstart: ((this: GlobalEventHandlers, ev: AnimationEvent) => any) | null;
+        onauxclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onbeforeinput: ((this: GlobalEventHandlers, ev: InputEvent) => any) | null;
+        onbeforetoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onblur: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        oncancel: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncanplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncanplaythrough: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onclose: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncontextlost: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncontextmenu: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        oncontextrestored: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncopy: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        oncuechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oncut: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        ondblclick: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        ondrag: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragend: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragenter: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragleave: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragover: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondragstart: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondrop: ((this: GlobalEventHandlers, ev: DragEvent) => any) | null;
+        ondurationchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onemptied: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onended: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onerror: OnErrorEventHandler;
+        onfocus: ((this: GlobalEventHandlers, ev: FocusEvent) => any) | null;
+        onformdata: ((this: GlobalEventHandlers, ev: FormDataEvent) => any) | null;
+        ongotpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        oninput: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        oninvalid: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onkeydown: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onkeypress: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onkeyup: ((this: GlobalEventHandlers, ev: KeyboardEvent) => any) | null;
+        onload: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadeddata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadedmetadata: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onloadstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onlostpointercapture: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onmousedown: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseenter: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseleave: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmousemove: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseout: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseover: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onmouseup: ((this: GlobalEventHandlers, ev: MouseEvent) => any) | null;
+        onpaste: ((this: GlobalEventHandlers, ev: ClipboardEvent) => any) | null;
+        onpause: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onplay: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onplaying: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onpointercancel: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerdown: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerenter: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerleave: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointermove: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerout: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerover: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onpointerup: ((this: GlobalEventHandlers, ev: PointerEvent) => any) | null;
+        onprogress: ((this: GlobalEventHandlers, ev: ProgressEvent) => any) | null;
+        onratechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onreset: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onresize: ((this: GlobalEventHandlers, ev: UIEvent) => any) | null;
+        onscroll: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onscrollend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onsecuritypolicyviolation: ((this: GlobalEventHandlers, ev: SecurityPolicyViolationEvent) => any) | null;
+        onseeked: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onseeking: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselect: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselectionchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onselectstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onslotchange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onstalled: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onsubmit: ((this: GlobalEventHandlers, ev: SubmitEvent) => any) | null;
+        onsuspend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontimeupdate: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontoggle: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        ontouchcancel?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+        ontouchend?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+        ontouchmove?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+        ontouchstart?: ((this: GlobalEventHandlers, ev: TouchEvent) => any) | null | undefined;
+        ontransitioncancel: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionend: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionrun: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        ontransitionstart: ((this: GlobalEventHandlers, ev: TransitionEvent) => any) | null;
+        onvolumechange: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwaiting: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationiteration: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkitanimationstart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwebkittransitionend: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+        onwheel: ((this: GlobalEventHandlers, ev: WheelEvent) => any) | null;
+        autofocus: boolean;
+        readonly dataset: DOMStringMap;
+        nonce?: string;
+        tabIndex: number;
+        blur(): void;
+        focus(options?: FocusOptions): void;
+    };
+} & T;
+export {};
+//# sourceMappingURL=debug.d.ts.map

package/dist/utilities/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../../source/utilities/debug.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,WAAW,CAAC,EAAE,OAAO,CAAC;KACvB;CACF;AASD,wBAAgB,KAAK,IAAI,OAAO,CAc/B;AAED,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACnC,IAAI,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACnC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,KAAK,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;IACpC,QAAQ,EAAE,MAAM,IAAI,CAAC;CACtB;AAQD,wBAAgB,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAuB1D;AAED,KAAK,WAAW,CAAC,CAAC,GAAG,WAAW,IAAI,KAAK,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;AAQ9D,QAAA,MAAM,cAAc,eAAwB,CAAC;AAE7C,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,WAAW,EAAE,IAAI,EAAE,CAAC;kBAIxC,GAAG,EAAE;;;uCAsBK,MAAM,YAAY,MAAM,GAAG,IAAI,YAAY,MAAM,GAAG,IAAI;0BAxBrE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgC3B"}

package/dist/utilities/debug.js

@@ -0,0 +1,71 @@
+function isDev() {
+  if (typeof window !== "undefined" && window.__UMD_DEV__ === true) {
+    return true;
+  }
+  try {
+    if (typeof process !== "undefined" && false) ;
+  } catch {
+  }
+  return false;
+}
+function createLogger(componentName) {
+  const prefix = `[UMD-DS:${componentName}]`;
+  return {
+    debug: (...args) => {
+      if (isDev()) console.debug(prefix, ...args);
+    },
+    info: (...args) => {
+      if (isDev()) console.info(prefix, ...args);
+    },
+    warn: (...args) => {
+      console.warn(prefix, ...args);
+    },
+    error: (...args) => {
+      console.error(prefix, ...args);
+    },
+    group: (...args) => {
+      if (isDev()) console.group(prefix, ...args);
+    },
+    groupEnd: () => {
+      if (isDev()) console.groupEnd();
+    }
+  };
+}
+const debugLoggerKey = /* @__PURE__ */ Symbol("debugLogger");
+function withLifecycleDebug(Base) {
+  var _a;
+  return class LifecycleDebug extends (_a = Base, _a) {
+    constructor(...args) {
+      super(...args);
+      const tag = this.tagName?.toLowerCase() ?? "unknown";
+      this[debugLoggerKey] = createLogger(tag);
+    }
+    connectedCallback() {
+      this[debugLoggerKey].debug("connectedCallback");
+      const superProto = Object.getPrototypeOf(Object.getPrototypeOf(this));
+      if (typeof superProto?.connectedCallback === "function") {
+        superProto.connectedCallback.call(this);
+      }
+    }
+    disconnectedCallback() {
+      this[debugLoggerKey].debug("disconnectedCallback");
+      const superProto = Object.getPrototypeOf(Object.getPrototypeOf(this));
+      if (typeof superProto?.disconnectedCallback === "function") {
+        superProto.disconnectedCallback.call(this);
+      }
+    }
+    attributeChangedCallback(name, oldValue, newValue) {
+      this[debugLoggerKey].debug("attributeChangedCallback", { name, oldValue, newValue });
+      const superProto = Object.getPrototypeOf(Object.getPrototypeOf(this));
+      if (typeof superProto?.attributeChangedCallback === "function") {
+        superProto.attributeChangedCallback.call(this, name, oldValue, newValue);
+      }
+    }
+  };
+}
+export {
+  createLogger,
+  isDev,
+  withLifecycleDebug
+};
+//# sourceMappingURL=debug.js.map

package/dist/utilities/debug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.js","sources":["../../source/utilities/debug.ts"],"sourcesContent":["declare global {\n  interface Window {\n    __UMD_DEV__?: boolean;\n  }\n}\n\n/**\n * Check if the current environment is development mode.\n *\n * - `window.__UMD_DEV__ === true` (strict boolean check)\n * - `process.env.NODE_ENV === 'development'` (replaced at build time by Vite)\n * - Returns `false` by default\n */\nexport function isDev(): boolean {\n  if (typeof window !== 'undefined' && window.__UMD_DEV__ === true) {\n    return true;\n  }\n\n  try {\n    if (typeof process !== 'undefined' && process.env?.NODE_ENV === 'development') {\n      return true;\n    }\n  } catch {\n    // Bundler edge cases where process is defined but access throws\n  }\n\n  return false;\n}\n\nexport interface Logger {\n  debug: (...args: unknown[]) => void;\n  info: (...args: unknown[]) => void;\n  warn: (...args: unknown[]) => void;\n  error: (...args: unknown[]) => void;\n  group: (...args: unknown[]) => void;\n  groupEnd: () => void;\n}\n\n/**\n * Create a prefixed logger for a component.\n *\n * - `warn` / `error` always log\n * - `debug` / `info` / `group` / `groupEnd` are gated by `isDev()`\n */\nexport function createLogger(componentName: string): Logger {\n  const prefix = `[UMD-DS:${componentName}]`;\n\n  return {\n    debug: (...args: unknown[]) => {\n      if (isDev()) console.debug(prefix, ...args);\n    },\n    info: (...args: unknown[]) => {\n      if (isDev()) console.info(prefix, ...args);\n    },\n    warn: (...args: unknown[]) => {\n      console.warn(prefix, ...args);\n    },\n    error: (...args: unknown[]) => {\n      console.error(prefix, ...args);\n    },\n    group: (...args: unknown[]) => {\n      if (isDev()) console.group(prefix, ...args);\n    },\n    groupEnd: () => {\n      if (isDev()) console.groupEnd();\n    },\n  };\n}\n\ntype Constructor<T = HTMLElement> = new (...args: any[]) => T;\n\n/**\n * Mixin that adds lifecycle debug logging to a custom element class.\n *\n * Wraps `connectedCallback`, `disconnectedCallback`, and `attributeChangedCallback`\n * with logger output. Logging is gated by `isDev()`.\n */\nconst debugLoggerKey = Symbol('debugLogger');\n\nexport function withLifecycleDebug<T extends Constructor>(Base: T) {\n  return class LifecycleDebug extends Base {\n    [debugLoggerKey]: Logger;\n\n    constructor(...args: any[]) {\n      super(...args);\n      const tag = (this as unknown as HTMLElement).tagName?.toLowerCase() ?? 'unknown';\n      this[debugLoggerKey] = createLogger(tag);\n    }\n\n    connectedCallback() {\n      this[debugLoggerKey].debug('connectedCallback');\n      const superProto = Object.getPrototypeOf(Object.getPrototypeOf(this));\n      if (typeof superProto?.connectedCallback === 'function') {\n        superProto.connectedCallback.call(this);\n      }\n    }\n\n    disconnectedCallback() {\n      this[debugLoggerKey].debug('disconnectedCallback');\n      const superProto = Object.getPrototypeOf(Object.getPrototypeOf(this));\n      if (typeof superProto?.disconnectedCallback === 'function') {\n        superProto.disconnectedCallback.call(this);\n      }\n    }\n\n    attributeChangedCallback(name: string, oldValue: string | null, newValue: string | null) {\n      this[debugLoggerKey].debug('attributeChangedCallback', { name, oldValue, newValue });\n      const superProto = Object.getPrototypeOf(Object.getPrototypeOf(this));\n      if (typeof superProto?.attributeChangedCallback === 'function') {\n        superProto.attributeChangedCallback.call(this, name, oldValue, newValue);\n      }\n    }\n  };\n}\n"],"names":[],"mappings":"AAaO,SAAS,QAAiB;AAC/B,MAAI,OAAO,WAAW,eAAe,OAAO,gBAAgB,MAAM;AAChE,WAAO;AAAA,EACT;AAEA,MAAI;AACF,QAAI,OAAO,YAAY,eAAe,MAAyC;AAAA,EAGjF,QAAQ;AAAA,EAER;AAEA,SAAO;AACT;AAiBO,SAAS,aAAa,eAA+B;AAC1D,QAAM,SAAS,WAAW,aAAa;AAEvC,SAAO;AAAA,IACL,OAAO,IAAI,SAAoB;AAC7B,UAAI,QAAS,SAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,IAC5C;AAAA,IACA,MAAM,IAAI,SAAoB;AAC5B,UAAI,QAAS,SAAQ,KAAK,QAAQ,GAAG,IAAI;AAAA,IAC3C;AAAA,IACA,MAAM,IAAI,SAAoB;AAC5B,cAAQ,KAAK,QAAQ,GAAG,IAAI;AAAA,IAC9B;AAAA,IACA,OAAO,IAAI,SAAoB;AAC7B,cAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,IAC/B;AAAA,IACA,OAAO,IAAI,SAAoB;AAC7B,UAAI,QAAS,SAAQ,MAAM,QAAQ,GAAG,IAAI;AAAA,IAC5C;AAAA,IACA,UAAU,MAAM;AACd,UAAI,MAAA,EAAS,SAAQ,SAAA;AAAA,IACvB;AAAA,EAAA;AAEJ;AAUA,MAAM,wCAAwB,aAAa;AAEpC,SAAS,mBAA0C,MAAS;AA/EnE,MAAA;AAgFE,SAAO,MAAM,wBAAuB,KAAA,MAAA,IAAK;AAAA,IAGvC,eAAe,MAAa;AAC1B,YAAM,GAAG,IAAI;AACb,YAAM,MAAO,KAAgC,SAAS,YAAA,KAAiB;AACvE,WAAK,cAAc,IAAI,aAAa,GAAG;AAAA,IACzC;AAAA,IAEA,oBAAoB;AAClB,WAAK,cAAc,EAAE,MAAM,mBAAmB;AAC9C,YAAM,aAAa,OAAO,eAAe,OAAO,eAAe,IAAI,CAAC;AACpE,UAAI,OAAO,YAAY,sBAAsB,YAAY;AACvD,mBAAW,kBAAkB,KAAK,IAAI;AAAA,MACxC;AAAA,IACF;AAAA,IAEA,uBAAuB;AACrB,WAAK,cAAc,EAAE,MAAM,sBAAsB;AACjD,YAAM,aAAa,OAAO,eAAe,OAAO,eAAe,IAAI,CAAC;AACpE,UAAI,OAAO,YAAY,yBAAyB,YAAY;AAC1D,mBAAW,qBAAqB,KAAK,IAAI;AAAA,MAC3C;AAAA,IACF;AAAA,IAEA,yBAAyB,MAAc,UAAyB,UAAyB;AACvF,WAAK,cAAc,EAAE,MAAM,4BAA4B,EAAE,MAAM,UAAU,UAAU;AACnF,YAAM,aAAa,OAAO,eAAe,OAAO,eAAe,IAAI,CAAC;AACpE,UAAI,OAAO,YAAY,6BAA6B,YAAY;AAC9D,mBAAW,yBAAyB,KAAK,MAAM,MAAM,UAAU,QAAQ;AAAA,MACzE;AAAA,IACF;AAAA,EAAA;AAEJ;"}

package/dist/utilities/dom.d.ts

@@ -0,0 +1,11 @@
+export type MutationObserverOptions = MutationObserverInit;
+export interface ResizeObserverOptionsConfig {
+    box?: ResizeObserverBoxOptions;
+}
+export type IntersectionObserverOptions = IntersectionObserverInit;
+export declare function createMutationObserver(target: Node, callback: MutationCallback, options?: MutationObserverOptions): () => void;
+export declare function createResizeObserver(target: Element, callback: ResizeObserverCallback, options?: ResizeObserverOptionsConfig): () => void;
+export declare function createIntersectionObserver(target: Element, callback: IntersectionObserverCallback, options?: IntersectionObserverOptions): () => void;
+export declare function querySlotted(slot: HTMLSlotElement, selector?: string): Element[];
+export declare function closestAcrossShadow(element: Element, selector: string): Element | null;
+//# sourceMappingURL=dom.d.ts.map

package/dist/utilities/dom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.d.ts","sourceRoot":"","sources":["../../source/utilities/dom.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,uBAAuB,GAAG,oBAAoB,CAAC;AAE3D,MAAM,WAAW,2BAA2B;IAC1C,GAAG,CAAC,EAAE,wBAAwB,CAAC;CAChC;AAED,MAAM,MAAM,2BAA2B,GAAG,wBAAwB,CAAC;AAEnE,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,IAAI,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,CAAC,EAAE,uBAAuB,GAChC,MAAM,IAAI,CAUZ;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,sBAAsB,EAChC,OAAO,CAAC,EAAE,2BAA2B,GACpC,MAAM,IAAI,CAUZ;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,4BAA4B,EACtC,OAAO,CAAC,EAAE,2BAA2B,GACpC,MAAM,IAAI,CAUZ;AAED,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,EACrB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,EAAE,CAIX;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,GACf,OAAO,GAAG,IAAI,CAgBhB"}

package/dist/utilities/dom.js

@@ -0,0 +1,57 @@
+function createMutationObserver(target, callback, options) {
+  const observer = new MutationObserver(callback);
+  observer.observe(target, options ?? { childList: true, subtree: true });
+  let disconnected = false;
+  return () => {
+    if (disconnected) return;
+    disconnected = true;
+    observer.disconnect();
+  };
+}
+function createResizeObserver(target, callback, options) {
+  const observer = new ResizeObserver(callback);
+  observer.observe(target, options);
+  let disconnected = false;
+  return () => {
+    if (disconnected) return;
+    disconnected = true;
+    observer.disconnect();
+  };
+}
+function createIntersectionObserver(target, callback, options) {
+  const observer = new IntersectionObserver(callback, options);
+  observer.observe(target);
+  let disconnected = false;
+  return () => {
+    if (disconnected) return;
+    disconnected = true;
+    observer.disconnect();
+  };
+}
+function querySlotted(slot, selector) {
+  const elements = slot.assignedElements({ flatten: true });
+  if (!selector) return elements;
+  return elements.filter((el) => el.matches(selector));
+}
+function closestAcrossShadow(element, selector) {
+  let current = element;
+  while (current) {
+    const match = current.closest(selector);
+    if (match) return match;
+    const root = current.getRootNode();
+    if (root instanceof ShadowRoot) {
+      current = root.host;
+    } else {
+      return null;
+    }
+  }
+  return null;
+}
+export {
+  closestAcrossShadow,
+  createIntersectionObserver,
+  createMutationObserver,
+  createResizeObserver,
+  querySlotted
+};
+//# sourceMappingURL=dom.js.map

package/dist/utilities/dom.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dom.js","sources":["../../source/utilities/dom.ts"],"sourcesContent":["export type MutationObserverOptions = MutationObserverInit;\n\nexport interface ResizeObserverOptionsConfig {\n  box?: ResizeObserverBoxOptions;\n}\n\nexport type IntersectionObserverOptions = IntersectionObserverInit;\n\nexport function createMutationObserver(\n  target: Node,\n  callback: MutationCallback,\n  options?: MutationObserverOptions,\n): () => void {\n  const observer = new MutationObserver(callback);\n  observer.observe(target, options ?? { childList: true, subtree: true });\n\n  let disconnected = false;\n  return () => {\n    if (disconnected) return;\n    disconnected = true;\n    observer.disconnect();\n  };\n}\n\nexport function createResizeObserver(\n  target: Element,\n  callback: ResizeObserverCallback,\n  options?: ResizeObserverOptionsConfig,\n): () => void {\n  const observer = new ResizeObserver(callback);\n  observer.observe(target, options);\n\n  let disconnected = false;\n  return () => {\n    if (disconnected) return;\n    disconnected = true;\n    observer.disconnect();\n  };\n}\n\nexport function createIntersectionObserver(\n  target: Element,\n  callback: IntersectionObserverCallback,\n  options?: IntersectionObserverOptions,\n): () => void {\n  const observer = new IntersectionObserver(callback, options);\n  observer.observe(target);\n\n  let disconnected = false;\n  return () => {\n    if (disconnected) return;\n    disconnected = true;\n    observer.disconnect();\n  };\n}\n\nexport function querySlotted(\n  slot: HTMLSlotElement,\n  selector?: string,\n): Element[] {\n  const elements = slot.assignedElements({ flatten: true });\n  if (!selector) return elements;\n  return elements.filter((el) => el.matches(selector));\n}\n\nexport function closestAcrossShadow(\n  element: Element,\n  selector: string,\n): Element | null {\n  let current: Element | null = element;\n\n  while (current) {\n    const match = current.closest(selector);\n    if (match) return match;\n\n    const root = current.getRootNode();\n    if (root instanceof ShadowRoot) {\n      current = root.host;\n    } else {\n      return null;\n    }\n  }\n\n  return null;\n}\n"],"names":[],"mappings":"AAQO,SAAS,uBACd,QACA,UACA,SACY;AACZ,QAAM,WAAW,IAAI,iBAAiB,QAAQ;AAC9C,WAAS,QAAQ,QAAQ,WAAW,EAAE,WAAW,MAAM,SAAS,MAAM;AAEtE,MAAI,eAAe;AACnB,SAAO,MAAM;AACX,QAAI,aAAc;AAClB,mBAAe;AACf,aAAS,WAAA;AAAA,EACX;AACF;AAEO,SAAS,qBACd,QACA,UACA,SACY;AACZ,QAAM,WAAW,IAAI,eAAe,QAAQ;AAC5C,WAAS,QAAQ,QAAQ,OAAO;AAEhC,MAAI,eAAe;AACnB,SAAO,MAAM;AACX,QAAI,aAAc;AAClB,mBAAe;AACf,aAAS,WAAA;AAAA,EACX;AACF;AAEO,SAAS,2BACd,QACA,UACA,SACY;AACZ,QAAM,WAAW,IAAI,qBAAqB,UAAU,OAAO;AAC3D,WAAS,QAAQ,MAAM;AAEvB,MAAI,eAAe;AACnB,SAAO,MAAM;AACX,QAAI,aAAc;AAClB,mBAAe;AACf,aAAS,WAAA;AAAA,EACX;AACF;AAEO,SAAS,aACd,MACA,UACW;AACX,QAAM,WAAW,KAAK,iBAAiB,EAAE,SAAS,MAAM;AACxD,MAAI,CAAC,SAAU,QAAO;AACtB,SAAO,SAAS,OAAO,CAAC,OAAO,GAAG,QAAQ,QAAQ,CAAC;AACrD;AAEO,SAAS,oBACd,SACA,UACgB;AAChB,MAAI,UAA0B;AAE9B,SAAO,SAAS;AACd,UAAM,QAAQ,QAAQ,QAAQ,QAAQ;AACtC,QAAI,MAAO,QAAO;AAElB,UAAM,OAAO,QAAQ,YAAA;AACrB,QAAI,gBAAgB,YAAY;AAC9B,gBAAU,KAAK;AAAA,IACjB,OAAO;AACL,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;"}

package/dist/utilities/events.d.ts

@@ -0,0 +1,22 @@
+export interface CustomEventOptions<T = unknown> {
+    detail?: T;
+    bubbles?: boolean;
+    cancelable?: boolean;
+    composed?: boolean;
+}
+export declare function createCustomEvent<T = unknown>(type: string, options?: CustomEventOptions<T>): CustomEvent<T>;
+export declare function dispatchCustomEvent<T = unknown>(element: EventTarget, type: string, options?: CustomEventOptions<T>): boolean;
+export interface DefineEvents<T extends {
+    [key: string]: unknown;
+}> {
+    types: {
+        [K in keyof T]: K;
+    };
+    dispatch<K extends keyof T & string>(element: EventTarget, type: K, detail?: T[K]): boolean;
+}
+export declare function defineEvents<T extends {
+    [key: string]: unknown;
+}>(): DefineEvents<T>;
+export declare function createEventListener<T extends Event = Event>(element: EventTarget, type: string, handler: (event: T) => void, options?: AddEventListenerOptions): () => void;
+export declare function delegate<T extends HTMLElement = HTMLElement>(container: HTMLElement, selector: string, eventType: string, handler: (event: Event, matched: T) => void, options?: AddEventListenerOptions): () => void;
+//# sourceMappingURL=events.d.ts.map

package/dist/utilities/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../source/utilities/events.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,OAAO;IAC7C,MAAM,CAAC,EAAE,CAAC,CAAC;IACX,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,iBAAiB,CAAC,CAAC,GAAG,OAAO,EAC3C,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,WAAW,CAAC,CAAC,CAAC,CAOhB;AAED,wBAAgB,mBAAmB,CAAC,CAAC,GAAG,OAAO,EAC7C,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAET;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE;IAChE,KAAK,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC;KAAE,CAAC;IAC7B,QAAQ,CAAC,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,EACjC,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,CAAC,EACP,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GACZ,OAAO,CAAC;CACZ;AAED,wBAAgB,YAAY,CAC1B,CAAC,SAAS;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,KACjC,YAAY,CAAC,CAAC,CAAC,CAgBnB;AAED,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,KAAK,GAAG,KAAK,EACzD,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAC3B,OAAO,CAAC,EAAE,uBAAuB,GAChC,MAAM,IAAI,CASZ;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC1D,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,KAAK,IAAI,EAC3C,OAAO,CAAC,EAAE,uBAAuB,GAChC,MAAM,IAAI,CAYZ"}

package/dist/utilities/events.js

@@ -0,0 +1,49 @@
+function createCustomEvent(type, options) {
+  return new CustomEvent(type, {
+    detail: options?.detail,
+    bubbles: options?.bubbles ?? true,
+    cancelable: options?.cancelable ?? false,
+    composed: options?.composed ?? true
+  });
+}
+function dispatchCustomEvent(element, type, options) {
+  return element.dispatchEvent(createCustomEvent(type, options));
+}
+function defineEvents() {
+  const types = new Proxy({}, {
+    get(_target, prop) {
+      return prop;
+    }
+  });
+  function dispatch(element, type, detail) {
+    return dispatchCustomEvent(element, type, { detail });
+  }
+  return { types, dispatch };
+}
+function createEventListener(element, type, handler, options) {
+  element.addEventListener(type, handler, options);
+  let removed = false;
+  return () => {
+    if (removed) return;
+    removed = true;
+    element.removeEventListener(type, handler, options);
+  };
+}
+function delegate(container, selector, eventType, handler, options) {
+  const listener = (event) => {
+    const target = event.target;
+    if (!target) return;
+    const matched = target.closest(selector);
+    if (!matched || !container.contains(matched)) return;
+    handler(event, matched);
+  };
+  return createEventListener(container, eventType, listener, options);
+}
+export {
+  createCustomEvent,
+  createEventListener,
+  defineEvents,
+  delegate,
+  dispatchCustomEvent
+};
+//# sourceMappingURL=events.js.map

package/dist/utilities/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sources":["../../source/utilities/events.ts"],"sourcesContent":["export interface CustomEventOptions<T = unknown> {\n  detail?: T;\n  bubbles?: boolean;\n  cancelable?: boolean;\n  composed?: boolean;\n}\n\nexport function createCustomEvent<T = unknown>(\n  type: string,\n  options?: CustomEventOptions<T>,\n): CustomEvent<T> {\n  return new CustomEvent<T>(type, {\n    detail: options?.detail as T,\n    bubbles: options?.bubbles ?? true,\n    cancelable: options?.cancelable ?? false,\n    composed: options?.composed ?? true,\n  });\n}\n\nexport function dispatchCustomEvent<T = unknown>(\n  element: EventTarget,\n  type: string,\n  options?: CustomEventOptions<T>,\n): boolean {\n  return element.dispatchEvent(createCustomEvent(type, options));\n}\n\nexport interface DefineEvents<T extends { [key: string]: unknown }> {\n  types: { [K in keyof T]: K };\n  dispatch<K extends keyof T & string>(\n    element: EventTarget,\n    type: K,\n    detail?: T[K],\n  ): boolean;\n}\n\nexport function defineEvents<\n  T extends { [key: string]: unknown },\n>(): DefineEvents<T> {\n  const types = new Proxy({} as { [K in keyof T]: K }, {\n    get(_target, prop: string) {\n      return prop;\n    },\n  });\n\n  function dispatch<K extends keyof T & string>(\n    element: EventTarget,\n    type: K,\n    detail?: T[K],\n  ): boolean {\n    return dispatchCustomEvent(element, type, { detail });\n  }\n\n  return { types, dispatch };\n}\n\nexport function createEventListener<T extends Event = Event>(\n  element: EventTarget,\n  type: string,\n  handler: (event: T) => void,\n  options?: AddEventListenerOptions,\n): () => void {\n  element.addEventListener(type, handler as EventListener, options);\n\n  let removed = false;\n  return () => {\n    if (removed) return;\n    removed = true;\n    element.removeEventListener(type, handler as EventListener, options);\n  };\n}\n\nexport function delegate<T extends HTMLElement = HTMLElement>(\n  container: HTMLElement,\n  selector: string,\n  eventType: string,\n  handler: (event: Event, matched: T) => void,\n  options?: AddEventListenerOptions,\n): () => void {\n  const listener = (event: Event) => {\n    const target = event.target as HTMLElement | null;\n    if (!target) return;\n\n    const matched = target.closest(selector) as T | null;\n    if (!matched || !container.contains(matched)) return;\n\n    handler(event, matched);\n  };\n\n  return createEventListener(container, eventType, listener, options);\n}\n"],"names":[],"mappings":"AAOO,SAAS,kBACd,MACA,SACgB;AAChB,SAAO,IAAI,YAAe,MAAM;AAAA,IAC9B,QAAQ,SAAS;AAAA,IACjB,SAAS,SAAS,WAAW;AAAA,IAC7B,YAAY,SAAS,cAAc;AAAA,IACnC,UAAU,SAAS,YAAY;AAAA,EAAA,CAChC;AACH;AAEO,SAAS,oBACd,SACA,MACA,SACS;AACT,SAAO,QAAQ,cAAc,kBAAkB,MAAM,OAAO,CAAC;AAC/D;AAWO,SAAS,eAEK;AACnB,QAAM,QAAQ,IAAI,MAAM,IAA6B;AAAA,IACnD,IAAI,SAAS,MAAc;AACzB,aAAO;AAAA,IACT;AAAA,EAAA,CACD;AAED,WAAS,SACP,SACA,MACA,QACS;AACT,WAAO,oBAAoB,SAAS,MAAM,EAAE,QAAQ;AAAA,EACtD;AAEA,SAAO,EAAE,OAAO,SAAA;AAClB;AAEO,SAAS,oBACd,SACA,MACA,SACA,SACY;AACZ,UAAQ,iBAAiB,MAAM,SAA0B,OAAO;AAEhE,MAAI,UAAU;AACd,SAAO,MAAM;AACX,QAAI,QAAS;AACb,cAAU;AACV,YAAQ,oBAAoB,MAAM,SAA0B,OAAO;AAAA,EACrE;AACF;AAEO,SAAS,SACd,WACA,UACA,WACA,SACA,SACY;AACZ,QAAM,WAAW,CAAC,UAAiB;AACjC,UAAM,SAAS,MAAM;AACrB,QAAI,CAAC,OAAQ;AAEb,UAAM,UAAU,OAAO,QAAQ,QAAQ;AACvC,QAAI,CAAC,WAAW,CAAC,UAAU,SAAS,OAAO,EAAG;AAE9C,YAAQ,OAAO,OAAO;AAAA,EACxB;AAEA,SAAO,oBAAoB,WAAW,WAAW,UAAU,OAAO;AACpE;"}

package/dist/utilities/index.d.ts

@@ -1,4 +1,11 @@
 export { registerWebComponent, webComponent, type WebComponentConfig } from './register';
 export { hooks, CommonLifecycleHooks } from './lifecycle';
 export { stylesTemplate as StylesTemplate } from './styles';
+export { isDev, createLogger, withLifecycleDebug } from './debug';
+export type { Logger } from './debug';
+export { createCustomEvent, dispatchCustomEvent, defineEvents, createEventListener, delegate, } from './events';
+export type { CustomEventOptions, DefineEvents } from './events';
+export { isElement, isHTMLElement, isCustomElement, isShadowRoot, isSlotElement, isTemplateElement, assertElement, assertHTMLElement, assertShadowRoot, } from './types';
+export { createMutationObserver, createResizeObserver, createIntersectionObserver, querySlotted, closestAcrossShadow, } from './dom';
+export type { MutationObserverOptions, ResizeObserverOptionsConfig, IntersectionObserverOptions, } from './dom';
 //# sourceMappingURL=index.d.ts.map

package/dist/utilities/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/utilities/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,cAAc,IAAI,cAAc,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../source/utilities/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,YAAY,CAAC;AACzF,OAAO,EAAE,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,EAAE,cAAc,IAAI,cAAc,EAAE,MAAM,UAAU,CAAC;AAC5D,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAClE,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,mBAAmB,EACnB,QAAQ,GACT,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AACjE,OAAO,EACL,SAAS,EACT,aAAa,EACb,eAAe,EACf,YAAY,EACZ,aAAa,EACb,iBAAiB,EACjB,aAAa,EACb,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,0BAA0B,EAC1B,YAAY,EACZ,mBAAmB,GACpB,MAAM,OAAO,CAAC;AACf,YAAY,EACV,uBAAuB,EACvB,2BAA2B,EAC3B,2BAA2B,GAC5B,MAAM,OAAO,CAAC"}

package/dist/utilities/register.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../source/utilities/register.ts"],"names":[],"mappings":"AAAA,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,wBAAwB,CAAC;CACnC;AAED,UAAU,oBAAoB;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,wBAAwB,CAAC;CACzC;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,aAAa,EAAE,oBAAoB,CAAC;KACrC;CACF;AAMD,QAAA,MAAM,oBAAoB,GAAI,mBAAmB,kBAAkB,KAAG,IAYrE,CAAC;AAEF,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAoB/E,wBAAgB,YAAY,CAC1B,MAAM,EAAE,sBAAsB,GAC7B,qBAAqB,CAiBvB;AAED,OAAO,EAAE,oBAAoB,EAAE,KAAK,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../source/utilities/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAK/E,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,wBAAwB,CAAC;CACnC;AAED,UAAU,oBAAoB;IAC5B,CAAC,GAAG,EAAE,MAAM,GAAG,wBAAwB,CAAC;CACzC;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,aAAa,EAAE,oBAAoB,CAAC;KACrC;CACF;AASD,QAAA,MAAM,oBAAoB,GAAI,mBAAmB,kBAAkB,KAAG,IAgBrE,CAAC;AAqBF,wBAAgB,YAAY,CAC1B,MAAM,EAAE,sBAAsB,GAC7B,qBAAqB,CA8BvB;AAED,OAAO,EAAE,oBAAoB,EAAE,KAAK,kBAAkB,EAAE,CAAC"}