@fluixi/utils 1.0.0-alpha.100

package/dist/lib/cookie/index.mjs

@@ -0,0 +1,53 @@
+/*! @fluixi/utils v1.0.0-alpha.100 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+
+// src/lib/cookie/codec.ts
+var NAME = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+function isValidCookieName(name) {
+  return NAME.test(name);
+}
+function decode(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function parseCookies(header) {
+  const out = {};
+  if (!header) return out;
+  for (const part of header.split(";")) {
+    const eq = part.indexOf("=");
+    if (eq < 0) continue;
+    const k = part.slice(0, eq).trim();
+    if (!k || k in out) continue;
+    let v = part.slice(eq + 1).trim();
+    if (v.length > 1 && v[0] === '"' && v[v.length - 1] === '"') v = v.slice(1, -1);
+    out[k] = decode(v);
+  }
+  return out;
+}
+function serializeCookie(name, value, opts = {}) {
+  if (!isValidCookieName(name)) throw new TypeError(`Invalid cookie name: ${JSON.stringify(name)}`);
+  const o = { path: "/", httpOnly: true, secure: true, sameSite: "lax", ...opts };
+  if (o.domain && /[;\s]/.test(o.domain)) throw new TypeError(`Invalid cookie domain: ${o.domain}`);
+  if (/[;\s]/.test(o.path)) throw new TypeError(`Invalid cookie path: ${o.path}`);
+  const secure = o.secure || o.sameSite === "none";
+  let s = `${name}=${encodeURIComponent(value)}`;
+  if (o.maxAge != null) s += `; Max-Age=${Math.floor(o.maxAge)}`;
+  if (o.expires) s += `; Expires=${o.expires.toUTCString()}`;
+  if (o.domain) s += `; Domain=${o.domain}`;
+  s += `; Path=${o.path}`;
+  if (o.httpOnly) s += "; HttpOnly";
+  if (secure) s += "; Secure";
+  s += `; SameSite=${o.sameSite[0].toUpperCase()}${o.sameSite.slice(1)}`;
+  return s;
+}
+function deleteCookie(name, opts = {}) {
+  return serializeCookie(name, "", { ...opts, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+}
+export {
+  deleteCookie,
+  isValidCookieName,
+  parseCookies,
+  serializeCookie
+};

package/dist/lib/crypto/hash.cjs

@@ -0,0 +1,83 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/crypto/hash.ts
+var hash_exports = {};
+__export(hash_exports, {
+  compareWithHash: () => compareWithHash,
+  createHash: () => createHash,
+  hash: () => hash,
+  hashStringPromise: () => hashStringPromise,
+  string_hash: () => string_hash
+});
+module.exports = __toCommonJS(hash_exports);
+var createHash = async (value, algorithm = "SHA-1") => {
+  if (typeof window === "undefined") return null;
+  const { subtle } = window.globalThis.crypto;
+  const key = await subtle.generateKey(
+    {
+      name: "HMAC",
+      hash: algorithm,
+      length: 256
+    },
+    true,
+    ["sign", "verify"]
+  );
+  const enc = new TextEncoder();
+  const message = enc.encode(value);
+  const digest = await subtle.sign(
+    {
+      name: "HMAC"
+    },
+    key,
+    message
+  );
+  const hex = [...new Uint8Array(digest)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hex;
+};
+var hash = async (value, algorithm = "SHA-256") => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+};
+var compareWithHash = async (value1, value2, algorithm = "SHA-256") => {
+  const hash1 = await hash(value1, algorithm);
+  const hash2 = await hash(value2, algorithm);
+  return hash1 === hash2;
+};
+async function hashStringPromise(value, algorithm = "SHA-256") {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+var string_hash = (str) => {
+  let hash2 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 = hash2 & hash2;
+  }
+  return hash2.toString(16);
+};

package/dist/lib/crypto/hash.d.ts

@@ -0,0 +1,6 @@
+export declare const createHash: (value: any, algorithm?: string) => Promise<string | null>;
+export declare const hash: (value: string, algorithm?: string) => Promise<string>;
+export declare const compareWithHash: (value1: string, value2: string, algorithm?: string) => Promise<boolean>;
+export declare function hashStringPromise(value: string, algorithm?: string): Promise<string>;
+export declare const string_hash: (str: string) => string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/lib/crypto/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../src/lib/crypto/hash.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,GAAU,OAAO,GAAG,EAAE,YAAW,MAAgB,2BA2BvE,CAAC;AAEF,eAAO,MAAM,IAAI,GAAU,OAAO,MAAM,EAAE,kBAAqB,oBAS9D,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,QAAQ,MAAM,EACd,QAAQ,MAAM,EACd,kBAAqB,qBAKtB,CAAC;AAGF,wBAAsB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,SAAY,mBAS3E;AAED,eAAO,MAAM,WAAW,GAAI,KAAK,MAAM,WAQtC,CAAC"}

package/dist/lib/crypto/hash.js

@@ -0,0 +1,53 @@
+export const createHash = async (value, algorithm = 'SHA-1') => {
+    if (typeof window === 'undefined')
+        return null;
+    const { subtle } = window.globalThis.crypto;
+    const key = await subtle.generateKey({
+        name: 'HMAC',
+        hash: algorithm,
+        length: 256,
+    }, true, ['sign', 'verify']);
+    const enc = new TextEncoder();
+    const message = enc.encode(value);
+    const digest = await subtle.sign({
+        name: 'HMAC',
+    }, key, message);
+    const hex = [...new Uint8Array(digest)]
+        .map((x) => x.toString(16).padStart(2, '0'))
+        .join('');
+    return hex;
+};
+export const hash = async (value, algorithm = 'SHA-256') => {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(value);
+    const hashBuffer = await crypto.subtle.digest(algorithm, data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return hashHex;
+};
+export const compareWithHash = async (value1, value2, algorithm = 'SHA-256') => {
+    const hash1 = await hash(value1, algorithm);
+    const hash2 = await hash(value2, algorithm);
+    return hash1 === hash2;
+};
+export async function hashStringPromise(value, algorithm = 'SHA-256') {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(value);
+    const hashBuffer = await crypto.subtle.digest(algorithm, data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+    return hashHex;
+}
+export const string_hash = (str) => {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return hash.toString(16);
+};

package/dist/lib/crypto/hash.mjs

@@ -0,0 +1,62 @@
+// src/lib/crypto/hash.ts
+var createHash = async (value, algorithm = "SHA-1") => {
+  if (typeof window === "undefined") return null;
+  const { subtle } = window.globalThis.crypto;
+  const key = await subtle.generateKey(
+    {
+      name: "HMAC",
+      hash: algorithm,
+      length: 256
+    },
+    true,
+    ["sign", "verify"]
+  );
+  const enc = new TextEncoder();
+  const message = enc.encode(value);
+  const digest = await subtle.sign(
+    {
+      name: "HMAC"
+    },
+    key,
+    message
+  );
+  const hex = [...new Uint8Array(digest)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hex;
+};
+var hash = async (value, algorithm = "SHA-256") => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+};
+var compareWithHash = async (value1, value2, algorithm = "SHA-256") => {
+  const hash1 = await hash(value1, algorithm);
+  const hash2 = await hash(value2, algorithm);
+  return hash1 === hash2;
+};
+async function hashStringPromise(value, algorithm = "SHA-256") {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+var string_hash = (str) => {
+  let hash2 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 = hash2 & hash2;
+  }
+  return hash2.toString(16);
+};
+export {
+  compareWithHash,
+  createHash,
+  hash,
+  hashStringPromise,
+  string_hash
+};

package/dist/lib/crypto/index.cjs

@@ -0,0 +1,85 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/crypto/index.ts
+var index_exports = {};
+__export(index_exports, {
+  compareWithHash: () => compareWithHash,
+  createHash: () => createHash,
+  hash: () => hash,
+  hashStringPromise: () => hashStringPromise,
+  string_hash: () => string_hash
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/lib/crypto/hash.ts
+var createHash = async (value, algorithm = "SHA-1") => {
+  if (typeof window === "undefined") return null;
+  const { subtle } = window.globalThis.crypto;
+  const key = await subtle.generateKey(
+    {
+      name: "HMAC",
+      hash: algorithm,
+      length: 256
+    },
+    true,
+    ["sign", "verify"]
+  );
+  const enc = new TextEncoder();
+  const message = enc.encode(value);
+  const digest = await subtle.sign(
+    {
+      name: "HMAC"
+    },
+    key,
+    message
+  );
+  const hex = [...new Uint8Array(digest)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hex;
+};
+var hash = async (value, algorithm = "SHA-256") => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+};
+var compareWithHash = async (value1, value2, algorithm = "SHA-256") => {
+  const hash1 = await hash(value1, algorithm);
+  const hash2 = await hash(value2, algorithm);
+  return hash1 === hash2;
+};
+async function hashStringPromise(value, algorithm = "SHA-256") {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+var string_hash = (str) => {
+  let hash2 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 = hash2 & hash2;
+  }
+  return hash2.toString(16);
+};

package/dist/lib/crypto/index.d.ts

@@ -0,0 +1,2 @@
+export * from './hash.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/crypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/crypto/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA"}

package/dist/lib/crypto/index.js

@@ -0,0 +1 @@
+export * from './hash.js';

package/dist/lib/crypto/index.mjs

@@ -0,0 +1,62 @@
+// src/lib/crypto/hash.ts
+var createHash = async (value, algorithm = "SHA-1") => {
+  if (typeof window === "undefined") return null;
+  const { subtle } = window.globalThis.crypto;
+  const key = await subtle.generateKey(
+    {
+      name: "HMAC",
+      hash: algorithm,
+      length: 256
+    },
+    true,
+    ["sign", "verify"]
+  );
+  const enc = new TextEncoder();
+  const message = enc.encode(value);
+  const digest = await subtle.sign(
+    {
+      name: "HMAC"
+    },
+    key,
+    message
+  );
+  const hex = [...new Uint8Array(digest)].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return hex;
+};
+var hash = async (value, algorithm = "SHA-256") => {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+};
+var compareWithHash = async (value1, value2, algorithm = "SHA-256") => {
+  const hash1 = await hash(value1, algorithm);
+  const hash2 = await hash(value2, algorithm);
+  return hash1 === hash2;
+};
+async function hashStringPromise(value, algorithm = "SHA-256") {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(value);
+  const hashBuffer = await crypto.subtle.digest(algorithm, data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hashHex;
+}
+var string_hash = (str) => {
+  let hash2 = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash2 = (hash2 << 5) - hash2 + char;
+    hash2 = hash2 & hash2;
+  }
+  return hash2.toString(16);
+};
+export {
+  compareWithHash,
+  createHash,
+  hash,
+  hashStringPromise,
+  string_hash
+};

package/dist/lib/dom/events.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/dom/events.ts
+var events_exports = {};
+__export(events_exports, {
+  isAddRemoveListenerTarget: () => isAddRemoveListenerTarget,
+  isDOMEventTarget: () => isDOMEventTarget,
+  isNodeEventEmitter: () => isNodeEventEmitter,
+  isOnOffTarget: () => isOnOffTarget
+});
+module.exports = __toCommonJS(events_exports);
+function isDOMEventTarget(target) {
+  return target && typeof target.addEventListener === "function";
+}
+function isNodeEventEmitter(target) {
+  return target && typeof target.addEventListener === "function" && typeof target.removeEventListener === "function";
+}
+function isOnOffTarget(target) {
+  return target && typeof target.on === "function" && typeof target.off === "function";
+}
+function isAddRemoveListenerTarget(target) {
+  return target && typeof target.addListener === "function" && typeof target.removeListener === "function";
+}

package/dist/lib/dom/events.d.ts

@@ -0,0 +1,159 @@
+/**
+ * A mapping of common DOM event names to their corresponding TypeScript event interfaces.
+ * This enables intelligent type inference for standard browser events.
+ *
+ * @interface DomEventMap
+ *
+ * @property {MouseEvent} 'click' - Mouse click events
+ * @property {MouseEvent} 'dblclick' - Mouse double-click events
+ * @property {MouseEvent} 'mousedown' - Mouse button down events
+ * @property {MouseEvent} 'mouseup' - Mouse button up events
+ * @property {MouseEvent} 'mousemove' - Mouse movement events
+ * @property {MouseEvent} 'mouseenter' - Mouse enter events
+ * @property {MouseEvent} 'mouseleave' - Mouse leave events
+ * @property {KeyboardEvent} 'keydown' - Keyboard key down events
+ * @property {KeyboardEvent} 'keyup' - Keyboard key up events
+ * @property {KeyboardEvent} 'keypress' - Keyboard key press events (deprecated)
+ * @property {Event} 'change' - Form change events
+ * @property {InputEvent} 'input' - Form input events
+ * @property {Event} 'submit' - Form submit events
+ * @property {FocusEvent} 'focus' - Element focus events
+ * @property {FocusEvent} 'blur' - Element blur events
+ * @property {DragEvent} 'drag' - Drag events
+ * @property {DragEvent} 'dragstart' - Drag start events
+ * @property {DragEvent} 'dragend' - Drag end events
+ * @property {DragEvent} 'dragover' - Drag over events
+ * @property {DragEvent} 'drop' - Drop events
+ * @property {Event} 'play' - Media play events
+ * @property {Event} 'pause' - Media pause events
+ * @property {Event} 'ended' - Media ended events
+ * @property {Event} 'load' - Resource load events
+ * @property {Event} 'unload' - Resource unload events
+ * @property {UIEvent} 'resize' - Window resize events
+ * @property {Event} 'scroll' - Scroll events
+ */
+export interface DomEventMap {
+    click: MouseEvent;
+    dblclick: MouseEvent;
+    mousedown: MouseEvent;
+    mouseup: MouseEvent;
+    mousemove: MouseEvent;
+    mouseenter: MouseEvent;
+    mouseleave: MouseEvent;
+    keydown: KeyboardEvent;
+    keyup: KeyboardEvent;
+    keypress: KeyboardEvent;
+    change: Event;
+    input: InputEvent;
+    submit: Event;
+    focus: FocusEvent;
+    blur: FocusEvent;
+    drag: DragEvent;
+    dragstart: DragEvent;
+    dragend: DragEvent;
+    dragover: DragEvent;
+    drop: DragEvent;
+    play: Event;
+    pause: Event;
+    ended: Event;
+    load: Event;
+    unload: Event;
+    resize: UIEvent;
+    scroll: Event;
+}
+/**
+ * Interface for Node.js EventEmitter compatibility.
+ * This allows `fromEvent` to work with Node.js event emitters.
+ *
+ * @interface NodeEventEmitter
+ *
+ * @method addEventListener - Adds an event listener (Node.js style)
+ * @param {string|symbol} event - The event name
+ * @param {Function} listener - The event listener function
+ *
+ * @method removeEventListener - Removes an event listener (Node.js style)
+ * @param {string|symbol} event - The event name
+ * @param {Function} listener - The event listener function
+ */
+export interface NodeEventEmitter {
+    addEventListener(event: string | symbol, listener: (...args: any[]) => void): void;
+    removeEventListener(event: string | symbol, listener: (...args: any[]) => void): void;
+}
+/**
+ * Union type representing all supported event target types.
+ * `fromEvent` can work with DOM elements, Node.js EventEmitters, jQuery-like objects,
+ * and any object with `on`/`off` or `addListener`/`removeListener` methods.
+ *
+ * @typedef {EventTarget|NodeEventEmitter|{on:Function, off:Function}|{addListener:Function, removeListener:Function}} EventTargetLike
+ */
+export type EventTargetLike = EventTarget | NodeEventEmitter | {
+    on(event: string, handler: (...args: any[]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
+} | {
+    addListener(event: string, handler: (...args: any[]) => void): void;
+    removeListener(event: string, handler: (...args: any[]) => void): void;
+};
+/**
+ * Infers the specific Event type based on the event name and target.
+ * This is a conditional type that provides intelligent type inference:
+ * 1. First checks against the standard DomEventMap
+ * 2. Then checks if the target has its own event type definitions
+ * 3. Falls back to the basic Event type
+ *
+ * @template EventName - The string literal type of the event name (e.g., 'click', 'keydown')
+ * @template Target - The type of the event target
+ *
+ * @example
+ * // Returns MouseEvent
+ * type ClickEvent = EventFor<'click', HTMLButtonElement>;
+ *
+ * @example
+ * // Returns KeyboardEvent
+ * type KeydownEvent = EventFor<'keydown', HTMLInputElement>;
+ */
+export type EventFor<EventName extends string, Target extends EventTargetLike = EventTarget> = EventName extends keyof DomEventMap ? DomEventMap[EventName] : Target extends {
+    addEventListener(type: infer E, listener: any, options?: any): any;
+} ? E extends string ? EventName extends E ? Event : never : Event : Event;
+/**
+ * Type guard to check if an object is a DOM EventTarget.
+ *
+ * @param {any} target - The object to check
+ * @returns {target is EventTarget} True if the object is a DOM EventTarget
+ *
+ * @private
+ */
+export declare function isDOMEventTarget(target: any): target is EventTarget;
+/**
+ * Type guard to check if an object is a Node.js EventEmitter.
+ *
+ * @param {any} target - The object to check
+ * @returns {target is NodeEventEmitter} True if the object is a NodeEventEmitter
+ *
+ * @private
+ */
+export declare function isNodeEventEmitter(target: any): target is NodeEventEmitter;
+/**
+ * Type guard to check if an object has on/off methods (jQuery-style).
+ *
+ * @param {any} target - The object to check
+ * @returns {target is {on: Function, off: Function}} True if the object has on/off methods
+ *
+ * @private
+ */
+export declare function isOnOffTarget(target: any): target is {
+    on: Function;
+    off: Function;
+};
+/**
+ * Type guard to check if an object has addListener/removeListener methods.
+ *
+ * @param {any} target - The object to check
+ * @returns {target is {addListener: Function, removeListener: Function}} True if the object has addListener/removeListener methods
+ *
+ * @private
+ */
+export declare function isAddRemoveListenerTarget(target: any): target is {
+    addListener: Function;
+    removeListener: Function;
+};
+//# sourceMappingURL=events.d.ts.map

package/dist/lib/dom/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/lib/dom/events.ts"],"names":[],"mappings":"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"}

package/dist/lib/dom/events.js

@@ -0,0 +1,50 @@
+/**
+ * Type guard to check if an object is a DOM EventTarget.
+ *
+ * @param {any} target - The object to check
+ * @returns {target is EventTarget} True if the object is a DOM EventTarget
+ *
+ * @private
+ */
+export function isDOMEventTarget(target) {
+    return target && typeof target.addEventListener === 'function';
+}
+/**
+ * Type guard to check if an object is a Node.js EventEmitter.
+ *
+ * @param {any} target - The object to check
+ * @returns {target is NodeEventEmitter} True if the object is a NodeEventEmitter
+ *
+ * @private
+ */
+export function isNodeEventEmitter(target) {
+    return (target &&
+        typeof target.addEventListener === 'function' &&
+        typeof target.removeEventListener === 'function');
+}
+/**
+ * Type guard to check if an object has on/off methods (jQuery-style).
+ *
+ * @param {any} target - The object to check
+ * @returns {target is {on: Function, off: Function}} True if the object has on/off methods
+ *
+ * @private
+ */
+export function isOnOffTarget(target) {
+    return (target &&
+        typeof target.on === 'function' &&
+        typeof target.off === 'function');
+}
+/**
+ * Type guard to check if an object has addListener/removeListener methods.
+ *
+ * @param {any} target - The object to check
+ * @returns {target is {addListener: Function, removeListener: Function}} True if the object has addListener/removeListener methods
+ *
+ * @private
+ */
+export function isAddRemoveListenerTarget(target) {
+    return (target &&
+        typeof target.addListener === 'function' &&
+        typeof target.removeListener === 'function');
+}