@adrianbutt/evutils 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Adrian Butt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+# HtmlAssetReplacer
+
+Utilities to help replace asset paths in HTML text (css and js links/assets).
+
+### Getting Started
+
+```sh
+npm install htmlassetreplacer
+```
+
+```ts
+export async function exampleUsage() {
+  const processor = new HtmlAssetReplacer();
+
+  const processURLCB = function (originalURI: string) {
+    return "https://my.cdn.com/assets/" + originalURI + "?token=abc";
+  };
+  const result = await processor.processHTML({
+    html: EXAMPLE_HTML_STR,
+    urlProcessor: processURLCB
+  });
+
+  console.log(result);
+  return result;
+}
+```

package/dist/cjs/index/index.d.ts

@@ -0,0 +1,7 @@
+import { BasicEventManager } from "@/src/BasicEventManager";
+import * as mapped from "@/src/mapped";
+declare const Index: {
+    BasicEventManager: typeof BasicEventManager;
+    mapped: typeof mapped;
+};
+export default Index;

package/dist/cjs/src/BasicEventManager.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Callback function.
+ */
+export type EventHandlerCallback = (...args: any) => void;
+/**
+ * Context used when calling a callback function
+ */
+export type EventHandlerContext = unknown;
+/**
+ * An event firer
+ */
+export interface IBasicEventDispatcher<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> {
+    trigger<T extends keyof TEventMap & string>(eventName: T, args: Parameters<TEventMap[T]>): boolean;
+}
+/**
+ * Interface that allows objects to subscribe to events
+ */
+export interface IBasicEventPublisher<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> {
+    on<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    off<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    register<T extends keyof TEventMap & string>(toState: boolean, eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+}
+/**
+ * Event subscriber and firer.
+ */
+export interface IBasicEventManager<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> extends IBasicEventPublisher<TEventMap>, IBasicEventDispatcher<TEventMap> {
+}
+/**
+ * A handler map, used to define the events that an event manager can send.
+ *
+ * @example
+ * ```ts
+ * type ServiceEvents = {
+ *    serviceLaunched: (name: string, timestamp: number) => void;
+ *    serviceStopped: (name: string, timestamp: number, reason: string) => void;
+ * }
+ * ```
+ */
+export type EventMapDef<T> = {
+    [key in keyof T]: EventHandlerCallback;
+};
+export type DefaultEventMap = Record<string, EventHandlerCallback>;
+/**
+ * Argument processor result.
+ * @returns
+ * If falsey the event should be cancelled.
+ * If true the event should be sent through without any param changes
+ * If an array said array will be used as arguments in the triggered event
+ */
+export type BasicEventManagerArgumentProcessorCallbackResult = unknown[] | boolean | null;
+/**
+ * Argument processor logic. Allows for custom processing when triggering events.
+ * @param eventName - the name of the event that will trigger
+ * @param args - the pending arguments of the event that will trigger
+ * @returns
+ * If falsey the event should be cancelled.
+ * If true the event should be sent through without any param changes
+ * If an array said array will be used as arguments in the triggered event
+ */
+export type BasicEventManagerArgumentProcessorCallback = (eventName: string, args: unknown[]) => BasicEventManagerArgumentProcessorCallbackResult;
+/**
+ * Logger used for logging.
+ */
+export type Logger = Pick<Console, "log" | "error" | "warn">;
+export declare class BasicEventManager<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> implements IBasicEventManager<TEventMap> {
+    private _safeMode;
+    private _listeners;
+    private _argProcessors;
+    private _logger?;
+    constructor();
+    trigger<T extends keyof TEventMap & string>(eventName: T, args: Parameters<TEventMap[T]>): boolean;
+    on<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    off<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    register<T extends keyof TEventMap & string>(toState: boolean, eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    hasCustomArgumentProcessor(eventName: string): boolean;
+    setCustomArgumentProcessor(eventName: string, processor: BasicEventManagerArgumentProcessorCallback | null, context?: EventHandlerContext): boolean;
+    get ignoreErrors(): boolean;
+    set ignoreErrors(v: boolean);
+    get logger(): Logger | null;
+    set logger(v: Logger | null);
+}
+/**
+ * Utility class that allows for simple setup of event registration,
+ * whilst keeping triggering hidden.
+ */
+export declare abstract class BasicEventPublisher<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> implements IBasicEventPublisher<TEventMap> {
+    protected _evManager: IBasicEventManager<TEventMap>;
+    constructor(evManager?: IBasicEventManager<TEventMap>);
+    on: IBasicEventManager<TEventMap>["on"];
+    off: IBasicEventManager<TEventMap>["off"];
+    register: IBasicEventManager<TEventMap>["register"];
+    protected _trigger: IBasicEventManager<TEventMap>["trigger"];
+}
+export declare function mixinEventPublisherUsingManager<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap>(ontoObject: IBasicEventPublisher<TEventMap>, usingManager: IBasicEventManager<TEventMap>): void;
+export default BasicEventManager;

package/dist/cjs/src/index.d.ts

@@ -0,0 +1 @@
+export { BasicEventManager } from "./BasicEventManager";

package/dist/cjs/src/mapped/EvForwarder.d.ts

@@ -0,0 +1,265 @@
+import type { IBasicEventPublisher, DefaultEventMap, EventHandlerContext, EventMapDef } from "@/src/BasicEventManager";
+/**
+ * Event param conditions
+ * <br> If a string, will be parsed and converted into an EvParamCondition
+ * @example
+ * ```ts
+ * // would check if the param at index 1 does exist (ie arguments >= 2 in length)
+ * '1'
+ * // would check if the param at index 1 does not exist (ie arguments < 2 in length)
+ * '1!'
+ * // would check if the param at index 1 IS 'Monday'
+ * '1="Monday"'
+ * '1="Monday" i' // (case insensitive)
+ * // would check if the param at index 1 is NOT 'Monday'
+ * '1!="Monday"'
+ * '1!="Monday" i' // (case insensitive)
+ * // would check if the param at index 1 starts with 'Mon'
+ * '1^="Mon"'
+ * '1^="Mon" i' // (case insensitive)
+ * // would check if the param at index 1 ends with 'day'
+ * '1$="day"'
+ * '1$="day" i' // (case insensitive)
+ * // would check if the param at index 1 contains the string 'day'
+ * '1*="day"'
+ * '1*="day" i' // (case insensitive)
+ * // would check if the param at index 1 was equal to 'Monday' or 'Tuesday'
+ * '1~="Monday Tuesday"'
+ * '1~="Monday Tuesday" i' // (case insensitive)
+ * ```
+ */
+export type EvParamConditionLike = EvParamCondition | string;
+/**
+ * Event parameter forwarding instructions
+ * <br> If a string, will be parsed and converted into an EvParamCondition
+ * @example
+ * ```ts
+ * // No parameters should be forwarded
+ * '!'
+ *
+ * '1'      // -> { from: 1,     to: 1                        }
+ * '2+'     // -> { from: 2,     to: Number.POSITIVE_INFINITY }
+ * '2-'     // -> { from: 2,     to: Number.NEGATIVE_INFINITY }
+ * '6-7'    // -> { from: 6,     to: 7                        }
+ * ```
+ */
+export type EvParamForwardInstructionLike = EvParamForwardInstruction | string;
+/**
+ * Essentially an {@link EvForwarderMap} with the option to specify strings as param properties
+ */
+export type EvForwarderConstructorEventMap = {
+    eventName: string;
+    forwardedEventName?: string;
+    paramConditions: EvParamConditionLike[];
+    paramForwardInstructions: EvParamForwardInstructionLike[];
+};
+/**
+ * Options to create an EvForwarder
+ * @property eventReceiver - the original or 'root' event broadcaster
+ * @property eventMaps - event forwarding instructions
+ * @property autoEnable - whether the forwarder should automatically connect to the eventReceiver
+ */
+export type EvForwarderConstructorOptions = {
+    eventReceiver: IBasicEventPublisher;
+    eventMaps: EvForwarderConstructorEventMap[];
+    autoEnable?: boolean;
+};
+/**
+ * Event forwarding instructions
+ * @property eventName - original event name
+ * @property forwardedEventName - the forwarded event name
+ *                                (if not provided, the original event name will be used)
+ * @property paramConditions - parameter conditions that the original event must clear
+ * @property paramForwardInstructions - how the original event's parameters should be forwarded.
+ *                                      (All will be forwarded if not present)
+ */
+export type EvForwarderMap = {
+    eventName: string;
+    forwardedEventName?: string;
+    paramConditions: EvParamCondition[];
+    paramForwardInstructions: EvParamForwardInstruction[];
+};
+/**
+ * Used to verify event params
+ * @property index - relevant zero-based parameter index
+ * @property operator - condition operator to run
+ * @property comparison - strings to compare with
+ * @property caseSensitive - whether the comparison should be case sensitive
+ *
+ */
+export type EvParamCondition = {
+    index: number;
+    operator: EvParamOperator;
+    comparison: string[];
+    caseSensitive: boolean;
+};
+/**
+ * Used to define what params should be forwarded in an event.
+ * <br><br>If both "from" and "to" are NaN -> no parameters should be forwarded
+ * <br><br>If both "from" or "to" are less than 0 -> the index is assumed to be an offset from params length
+ * @property from - start index
+ * @property to - end index
+ */
+export type EvParamForwardInstruction = {
+    from: number;
+    to: number;
+};
+/**
+ * Operator for param verification.
+ * @sortStrategy source-order
+ */
+export declare enum EvParamOperator {
+    /**
+     * Whether the parameter does not exist.
+     * <br> NOTE: No suffix is expected after using EXISTS.
+     * @example
+     * ```ts
+     * // would check if the param at index 1 does exist (ie arguments >= 2 in length)
+     * '1_'
+     * // is functionally equivalent to having NO operator
+     * '1'
+     * ```
+     */
+    EXISTS = "_",
+    /**
+     * Whether the parameter does not exist.
+     * <br> NOTE: No suffix is expected after using NOT_EXISTS.
+     * @example
+     * ```ts
+     * // would check if the param at index 1 does not exist (ie arguments < 2 in length)
+     * '1!'
+     * ```
+     */
+    NOT_EXISTS = "!",
+    /**
+     * Whether the value is equal to a string
+     * @example
+     * ```ts
+     * // would check if the param at index 1 IS 'monday'
+     * '1="monday"'
+     * ```
+     */
+    EQUAL = "=",
+    /**
+     * Whether the value is not equal to a string
+     * @example
+     * ```ts
+     * // would check if the param at index 1 is NOT 'monday'
+     * '1!="monday"'
+     * ```
+     */
+    NOT_EQUAL = "!=",
+    /**
+     * Whether the value ends with a string
+     * @example
+     * ```ts
+     * // would check if the param at index 1 starts with 'mon'
+     * '1^="mon"'
+     * ```
+     */
+    STARTS_WITH = "^=",
+    /**
+     * Whether the value ends with a string
+     * @example
+     * ```ts
+     * // would check if the param at index 1 ends with 'day'
+     * '1$="day"'
+     * ```
+     */
+    ENDS_WITH = "$=",
+    /**
+     * Whether the value contains a string
+     * @example
+     * ```ts
+     * // would check if the param at index 1 contains the string 'day'
+     * '1*="day"'
+     * ```
+     */
+    CONTAINS = "*=",
+    /**
+     * Exact match for space separated words
+     * @example
+     * ```ts
+     * // would check if the param at index 1 was equal to 'monday' or 'tuesday'
+     * '1~="monday tuesday"'
+     * ```
+     */
+    MATCHES_WORD = "~="
+}
+/**
+ * Event forwarder
+ *
+ * @example
+ * ```ts
+ * const rootEvMgr = new BasicEventManager();
+ * const evFwder = new EvForwarder({
+ *   eventReceiver: rootEvMgr,
+ *   eventMaps: [{
+ *     eventName: "FoodEvent",
+ *     paramConditions: [],
+ *     paramForwardInstructions: []
+ *   }, {
+ *     eventName: "FoodEvent",
+ *     forwardedEventName: "AteFood",
+ *     paramConditions: ['0="Ate"'],
+ *     paramForwardInstructions: ["2"]
+ *   }, {
+ *     eventName: "FoodEvent",
+ *     forwardedEventName: "AteSnack",
+ *     paramConditions: ['0="Ate"', '1="Snack"'],
+ *     paramForwardInstructions: ["2"]
+ *   }],
+ *   autoEnable: true
+ * });
+ *
+ * const handleFoodEvent = function () {};
+ * const handleAteFood = function () {};
+ * const handleAteSnack = function () {};
+ * evFwder.on("FoodEvent", handleFoodEvent);
+ * evFwder.on("AteFood", handleAteFood);
+ * evFwder.on("AteSnack", handleAteSnack);
+ *
+ * rootEvMgr.trigger("FoodEvent", []);
+ * rootEvMgr.trigger("FoodEvent", ["Ate", "Snack", "Chocolate"]);
+ * rootEvMgr.trigger("FoodEvent", ["Ate", "Snack", "Biscuit"]);
+ * rootEvMgr.trigger("FoodEvent", ["Ate", "Meal", "Sandwich"]);
+ * rootEvMgr.trigger("FoodEvent", ["Drank", "Soft", "Lemonade"]);
+ * rootEvMgr.trigger("FoodEvent", ["Drank", "Hard", "Vodka"]);
+ *
+ * // handleFoodEvent invocations:
+ * //   handleFoodEvent();
+ * //   handleFoodEvent("Ate", "Snack", "Chocolate");
+ * //   handleFoodEvent("Ate", "Snack", "Biscuit");
+ * //   handleFoodEvent("Ate", "Meal", "Sandwich");
+ * //   handleFoodEvent("Drank", "Soft", "Lemonade");
+ * //   handleFoodEvent("Drank", "Hard", "Vodka");
+ *
+ * // handleAteFood invocations:
+ * //   handleAteFood("Chocolate");
+ * //   handleAteFood("Biscuit");
+ * //   handleAteFood("Sandwich");
+ *
+ * // handleAteSnack invocations:
+ * //   handleAteSnack("Chocolate");
+ * //   handleAteSnack("Biscuit");
+ * ```
+ */
+export declare class EvForwarder<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> implements IBasicEventPublisher<TEventMap> {
+    private _evReceiver;
+    private _evMgr;
+    private _evMaps;
+    private _active?;
+    constructor(options: EvForwarderConstructorOptions);
+    /**
+     * Whether the forwarder should forward events or not.
+     */
+    get active(): boolean;
+    /**
+     * Whether the forwarder should forward events or not.
+     */
+    set active(to: boolean);
+    on<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    off<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    register<T extends keyof TEventMap & string>(toState: boolean, eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    private _refreshListeners;
+}

package/dist/cjs/src/mapped/index.d.ts

@@ -0,0 +1 @@
+export * from "./EvForwarder";

package/dist/cjs/src/mapped/utils.d.ts

@@ -0,0 +1,36 @@
+import type { EvParamCondition, EvParamForwardInstruction, EvParamOperator } from "./EvForwarder";
+export declare function parseEvParamConditionStr(str: string): EvParamCondition;
+export declare function parseEvParamForwardInstructionStr(str: string): EvParamForwardInstruction;
+export type ParamCheckOptions = {
+    operator: EvParamOperator;
+    rawValue: string;
+    comparison: string[];
+    caseSensitive: boolean;
+};
+export declare function paramCheck(options: ParamCheckOptions): boolean;
+type InternalParamCheckCallbackOptions = Pick<ParamCheckOptions, "rawValue" | "comparison" | "caseSensitive">;
+/**
+ * @internal
+ */
+export declare function paramCheck_EqualTo({ rawValue, comparison, caseSensitive }: InternalParamCheckCallbackOptions): boolean;
+/**
+ * @internal
+ */
+export declare function paramCheck_NotEqualTo({ rawValue, comparison, caseSensitive }: InternalParamCheckCallbackOptions): boolean;
+/**
+ * @internal
+ */
+export declare function paramCheck_StartsWith({ rawValue, comparison, caseSensitive }: InternalParamCheckCallbackOptions): boolean;
+/**
+ * @internal
+ */
+export declare function paramCheck_EndsWith({ rawValue, comparison, caseSensitive }: InternalParamCheckCallbackOptions): boolean;
+/**
+ * @internal
+ */
+export declare function paramCheck_Contains({ rawValue, comparison, caseSensitive }: InternalParamCheckCallbackOptions): boolean;
+/**
+ * @internal
+ */
+export declare function paramCheck_MatchesWord(options: InternalParamCheckCallbackOptions): boolean;
+export {};

package/dist/mjs/index/index.d.ts

@@ -0,0 +1,7 @@
+import { BasicEventManager } from "../src/BasicEventManager.js";
+import * as mapped from "../src/mapped/index.js";
+declare const Index: {
+    BasicEventManager: typeof BasicEventManager;
+    mapped: typeof mapped;
+};
+export default Index;

package/dist/mjs/index/index.js

@@ -0,0 +1,8 @@
+import { BasicEventManager } from "../src/BasicEventManager.js";
+import * as mapped from "../src/mapped/index.js";
+const Index = {
+    BasicEventManager,
+    mapped
+};
+export default Index;
+//# sourceMappingURL=index.js.map

package/dist/mjs/index/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../index/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,MAAM,MAAM,cAAc,CAAC;AAEvC,MAAM,KAAK,GAAG;IACZ,iBAAiB;IACjB,MAAM;CACP,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/mjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/mjs/src/BasicEventManager.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Callback function.
+ */
+export type EventHandlerCallback = (...args: any) => void;
+/**
+ * Context used when calling a callback function
+ */
+export type EventHandlerContext = unknown;
+/**
+ * An event firer
+ */
+export interface IBasicEventDispatcher<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> {
+    trigger<T extends keyof TEventMap & string>(eventName: T, args: Parameters<TEventMap[T]>): boolean;
+}
+/**
+ * Interface that allows objects to subscribe to events
+ */
+export interface IBasicEventPublisher<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> {
+    on<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    off<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    register<T extends keyof TEventMap & string>(toState: boolean, eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+}
+/**
+ * Event subscriber and firer.
+ */
+export interface IBasicEventManager<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> extends IBasicEventPublisher<TEventMap>, IBasicEventDispatcher<TEventMap> {
+}
+/**
+ * A handler map, used to define the events that an event manager can send.
+ *
+ * @example
+ * ```ts
+ * type ServiceEvents = {
+ *    serviceLaunched: (name: string, timestamp: number) => void;
+ *    serviceStopped: (name: string, timestamp: number, reason: string) => void;
+ * }
+ * ```
+ */
+export type EventMapDef<T> = {
+    [key in keyof T]: EventHandlerCallback;
+};
+export type DefaultEventMap = Record<string, EventHandlerCallback>;
+/**
+ * Argument processor result.
+ * @returns
+ * If falsey the event should be cancelled.
+ * If true the event should be sent through without any param changes
+ * If an array said array will be used as arguments in the triggered event
+ */
+export type BasicEventManagerArgumentProcessorCallbackResult = unknown[] | boolean | null;
+/**
+ * Argument processor logic. Allows for custom processing when triggering events.
+ * @param eventName - the name of the event that will trigger
+ * @param args - the pending arguments of the event that will trigger
+ * @returns
+ * If falsey the event should be cancelled.
+ * If true the event should be sent through without any param changes
+ * If an array said array will be used as arguments in the triggered event
+ */
+export type BasicEventManagerArgumentProcessorCallback = (eventName: string, args: unknown[]) => BasicEventManagerArgumentProcessorCallbackResult;
+/**
+ * Logger used for logging.
+ */
+export type Logger = Pick<Console, "log" | "error" | "warn">;
+export declare class BasicEventManager<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> implements IBasicEventManager<TEventMap> {
+    private _safeMode;
+    private _listeners;
+    private _argProcessors;
+    private _logger?;
+    constructor();
+    trigger<T extends keyof TEventMap & string>(eventName: T, args: Parameters<TEventMap[T]>): boolean;
+    on<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    off<T extends keyof TEventMap & string>(eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    register<T extends keyof TEventMap & string>(toState: boolean, eventName: T, handler: TEventMap[T], context?: EventHandlerContext): boolean;
+    hasCustomArgumentProcessor(eventName: string): boolean;
+    setCustomArgumentProcessor(eventName: string, processor: BasicEventManagerArgumentProcessorCallback | null, context?: EventHandlerContext): boolean;
+    get ignoreErrors(): boolean;
+    set ignoreErrors(v: boolean);
+    get logger(): Logger | null;
+    set logger(v: Logger | null);
+}
+/**
+ * Utility class that allows for simple setup of event registration,
+ * whilst keeping triggering hidden.
+ */
+export declare abstract class BasicEventPublisher<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap> implements IBasicEventPublisher<TEventMap> {
+    protected _evManager: IBasicEventManager<TEventMap>;
+    constructor(evManager?: IBasicEventManager<TEventMap>);
+    on: IBasicEventManager<TEventMap>["on"];
+    off: IBasicEventManager<TEventMap>["off"];
+    register: IBasicEventManager<TEventMap>["register"];
+    protected _trigger: IBasicEventManager<TEventMap>["trigger"];
+}
+export declare function mixinEventPublisherUsingManager<TEventMap extends EventMapDef<TEventMap> = DefaultEventMap>(ontoObject: IBasicEventPublisher<TEventMap>, usingManager: IBasicEventManager<TEventMap>): void;
+export default BasicEventManager;