hookified 1.12.1 → 1.13.0

package/dist/browser/index.global.js

@@ -1,2 +1,616 @@
-"use strict";(()=>{var g=Object.defineProperty;var p=(n,t,e)=>t in n?g(n,t,{enumerable:!0,configurable:!0,writable:!0,value:e}):n[t]=e;var i=(n,t,e)=>p(n,typeof t!="symbol"?t+"":t,e);var a=class{constructor(t){i(this,"_eventListeners");i(this,"_maxListeners");i(this,"_logger");i(this,"_throwOnEmitError",!1);this._eventListeners=new Map,this._maxListeners=100,this._logger=t?.logger,t?.throwOnEmitError!==void 0&&(this._throwOnEmitError=t.throwOnEmitError)}get logger(){return this._logger}set logger(t){this._logger=t}get throwOnEmitError(){return this._throwOnEmitError}set throwOnEmitError(t){this._throwOnEmitError=t}once(t,e){let r=(...s)=>{this.off(t,r),e(...s)};return this.on(t,r),this}listenerCount(t){if(t===void 0)return this.getAllListeners().length;let e=this._eventListeners.get(t);return e?e.length:0}eventNames(){return[...this._eventListeners.keys()]}rawListeners(t){return t===void 0?this.getAllListeners():this._eventListeners.get(t)??[]}prependListener(t,e){let r=this._eventListeners.get(t)??[];return r.unshift(e),this._eventListeners.set(t,r),this}prependOnceListener(t,e){let r=(...s)=>{this.off(t,r),e(...s)};return this.prependListener(t,r),this}maxListeners(){return this._maxListeners}addListener(t,e){return this.on(t,e),this}on(t,e){this._eventListeners.has(t)||this._eventListeners.set(t,[]);let r=this._eventListeners.get(t);return r&&(r.length>=this._maxListeners&&console.warn(`MaxListenersExceededWarning: Possible event memory leak detected. ${r.length+1} ${t} listeners added. Use setMaxListeners() to increase limit.`),r.push(e)),this}removeListener(t,e){return this.off(t,e),this}off(t,e){let r=this._eventListeners.get(t)??[],s=r.indexOf(e);return s!==-1&&r.splice(s,1),r.length===0&&this._eventListeners.delete(t),this}emit(t,...e){let r=!1,s=this._eventListeners.get(t);if(s&&s.length>0)for(let o of s)o(...e),r=!0;if(t==="error"){let o=e[0]instanceof Error?e[0]:new Error(`${e[0]}`);if(this._throwOnEmitError&&!r)throw o}return r}listeners(t){return this._eventListeners.get(t)??[]}removeAllListeners(t){return t!==void 0?this._eventListeners.delete(t):this._eventListeners.clear(),this}setMaxListeners(t){this._maxListeners=t;for(let e of this._eventListeners.values())e.length>t&&e.splice(t)}getAllListeners(){let t=[];for(let e of this._eventListeners.values())t=[...t,...e];return t}};var h=class extends a{constructor(e){super({logger:e?.logger});i(this,"_hooks");i(this,"_throwHookErrors",!1);i(this,"_enforceBeforeAfter",!1);i(this,"_deprecatedHooks");i(this,"_allowDeprecated",!0);this._hooks=new Map,this._deprecatedHooks=e?.deprecatedHooks?new Map(e.deprecatedHooks):new Map,e?.throwHookErrors!==void 0&&(this._throwHookErrors=e.throwHookErrors),e?.enforceBeforeAfter!==void 0&&(this._enforceBeforeAfter=e.enforceBeforeAfter),e?.allowDeprecated!==void 0&&(this._allowDeprecated=e.allowDeprecated)}get hooks(){return this._hooks}get throwHookErrors(){return this._throwHookErrors}set throwHookErrors(e){this._throwHookErrors=e}get enforceBeforeAfter(){return this._enforceBeforeAfter}set enforceBeforeAfter(e){this._enforceBeforeAfter=e}get deprecatedHooks(){return this._deprecatedHooks}set deprecatedHooks(e){this._deprecatedHooks=e}get allowDeprecated(){return this._allowDeprecated}set allowDeprecated(e){this._allowDeprecated=e}validateHookName(e){if(this._enforceBeforeAfter){let r=e.trim().toLocaleLowerCase();if(!r.startsWith("before")&&!r.startsWith("after"))throw new Error(`Hook event "${e}" must start with "before" or "after" when enforceBeforeAfter is enabled`)}}checkDeprecatedHook(e){if(this._deprecatedHooks.has(e)){let r=this._deprecatedHooks.get(e),s=`Hook "${e}" is deprecated${r?`: ${r}`:""}`;return this.emit("warn",{hook:e,message:s}),this.logger?.warn&&this.logger.warn(s),this._allowDeprecated}return!0}onHook(e,r){if(this.validateHookName(e),!this.checkDeprecatedHook(e))return;let s=this._hooks.get(e);s?s.push(r):this._hooks.set(e,[r])}onHookEntry(e){this.onHook(e.event,e.handler)}addHook(e,r){this.onHook(e,r)}onHooks(e){for(let r of e)this.onHook(r.event,r.handler)}prependHook(e,r){if(this.validateHookName(e),!this.checkDeprecatedHook(e))return;let s=this._hooks.get(e);s?s.unshift(r):this._hooks.set(e,[r])}prependOnceHook(e,r){if(this.validateHookName(e),!this.checkDeprecatedHook(e))return;let s=async(...o)=>(this.removeHook(e,s),r(...o));this.prependHook(e,s)}onceHook(e,r){if(this.validateHookName(e),!this.checkDeprecatedHook(e))return;let s=async(...o)=>(this.removeHook(e,s),r(...o));this.onHook(e,s)}removeHook(e,r){if(this.validateHookName(e),!this.checkDeprecatedHook(e))return;let s=this._hooks.get(e);if(s){let o=s.indexOf(r);o!==-1&&s.splice(o,1)}}removeHooks(e){for(let r of e)this.removeHook(r.event,r.handler)}async hook(e,...r){if(this.validateHookName(e),!this.checkDeprecatedHook(e))return;let s=this._hooks.get(e);if(s)for(let o of s)try{await o(...r)}catch(c){let l=`${e}: ${c.message}`;if(this.emit("error",new Error(l)),this.logger&&this.logger.error(l),this._throwHookErrors)throw new Error(l)}}async beforeHook(e,...r){await this.hook(`before:${e}`,...r)}async afterHook(e,...r){await this.hook(`after:${e}`,...r)}async callHook(e,...r){await this.hook(e,...r)}getHooks(e){if(this.validateHookName(e),!!this.checkDeprecatedHook(e))return this._hooks.get(e)}clearHooks(){this._hooks.clear()}};})();
+"use strict";
+(() => {
+  var __defProp = Object.defineProperty;
+  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/eventified.ts
+  var Eventified = class {
+    constructor(options) {
+      __publicField(this, "_eventListeners");
+      __publicField(this, "_maxListeners");
+      __publicField(this, "_logger");
+      __publicField(this, "_throwOnEmitError", false);
+      __publicField(this, "_throwOnEmptyListeners", false);
+      __publicField(this, "_errorEvent", "error");
+      this._eventListeners = /* @__PURE__ */ new Map();
+      this._maxListeners = 100;
+      this._logger = options?.logger;
+      if (options?.throwOnEmitError !== void 0) {
+        this._throwOnEmitError = options.throwOnEmitError;
+      }
+      if (options?.throwOnEmptyListeners !== void 0) {
+        this._throwOnEmptyListeners = options.throwOnEmptyListeners;
+      }
+    }
+    /**
+     * Gets the logger
+     * @returns {Logger}
+     */
+    get logger() {
+      return this._logger;
+    }
+    /**
+     * Sets the logger
+     * @param {Logger} logger
+     */
+    set logger(logger) {
+      this._logger = logger;
+    }
+    /**
+     * Gets whether an error should be thrown when an emit throws an error. Default is false and only emits an error event.
+     * @returns {boolean}
+     */
+    get throwOnEmitError() {
+      return this._throwOnEmitError;
+    }
+    /**
+     * Sets whether an error should be thrown when an emit throws an error. Default is false and only emits an error event.
+     * @param {boolean} value
+     */
+    set throwOnEmitError(value) {
+      this._throwOnEmitError = value;
+    }
+    /**
+     * Gets whether an error should be thrown when emitting 'error' event with no listeners. Default is false.
+     * @returns {boolean}
+     */
+    get throwOnEmptyListeners() {
+      return this._throwOnEmptyListeners;
+    }
+    /**
+     * Sets whether an error should be thrown when emitting 'error' event with no listeners. Default is false.
+     * @param {boolean} value
+     */
+    set throwOnEmptyListeners(value) {
+      this._throwOnEmptyListeners = value;
+    }
+    /**
+     * Adds a handler function for a specific event that will run only once
+     * @param {string | symbol} eventName
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    once(eventName, listener) {
+      const onceListener = (...arguments_) => {
+        this.off(eventName, onceListener);
+        listener(...arguments_);
+      };
+      this.on(eventName, onceListener);
+      return this;
+    }
+    /**
+     * Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
+     * @param {string} eventName The event name. Not required
+     * @returns {number} The number of listeners
+     */
+    listenerCount(eventName) {
+      if (eventName === void 0) {
+        return this.getAllListeners().length;
+      }
+      const listeners = this._eventListeners.get(eventName);
+      return listeners ? listeners.length : 0;
+    }
+    /**
+     * Gets an array of event names
+     * @returns {Array<string | symbol>} An array of event names
+     */
+    eventNames() {
+      return [...this._eventListeners.keys()];
+    }
+    /**
+     * Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
+     * @param {string} [event] (Optional) The event name
+     * @returns {EventListener[]} An array of listeners
+     */
+    rawListeners(event) {
+      if (event === void 0) {
+        return this.getAllListeners();
+      }
+      return this._eventListeners.get(event) ?? [];
+    }
+    /**
+     * Prepends a listener to the beginning of the listeners array for the specified event
+     * @param {string | symbol} eventName
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    prependListener(eventName, listener) {
+      const listeners = this._eventListeners.get(eventName) ?? [];
+      listeners.unshift(listener);
+      this._eventListeners.set(eventName, listeners);
+      return this;
+    }
+    /**
+     * Prepends a one-time listener to the beginning of the listeners array for the specified event
+     * @param {string | symbol} eventName
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    prependOnceListener(eventName, listener) {
+      const onceListener = (...arguments_) => {
+        this.off(eventName, onceListener);
+        listener(...arguments_);
+      };
+      this.prependListener(eventName, onceListener);
+      return this;
+    }
+    /**
+     * Gets the maximum number of listeners that can be added for a single event
+     * @returns {number} The maximum number of listeners
+     */
+    maxListeners() {
+      return this._maxListeners;
+    }
+    /**
+     * Adds a listener for a specific event. It is an alias for the on() method
+     * @param {string | symbol} event
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    addListener(event, listener) {
+      this.on(event, listener);
+      return this;
+    }
+    /**
+     * Adds a listener for a specific event
+     * @param {string | symbol} event
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    on(event, listener) {
+      if (!this._eventListeners.has(event)) {
+        this._eventListeners.set(event, []);
+      }
+      const listeners = this._eventListeners.get(event);
+      if (listeners) {
+        if (listeners.length >= this._maxListeners) {
+          console.warn(
+            `MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`
+          );
+        }
+        listeners.push(listener);
+      }
+      return this;
+    }
+    /**
+     * Removes a listener for a specific event. It is an alias for the off() method
+     * @param {string | symbol} event
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    removeListener(event, listener) {
+      this.off(event, listener);
+      return this;
+    }
+    /**
+     * Removes a listener for a specific event
+     * @param {string | symbol} event
+     * @param {EventListener} listener
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    off(event, listener) {
+      const listeners = this._eventListeners.get(event) ?? [];
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+      if (listeners.length === 0) {
+        this._eventListeners.delete(event);
+      }
+      return this;
+    }
+    /**
+     * Calls all listeners for a specific event
+     * @param {string | symbol} event
+     * @param arguments_ The arguments to pass to the listeners
+     * @returns {boolean} Returns true if the event had listeners, false otherwise
+     */
+    emit(event, ...arguments_) {
+      let result = false;
+      const listeners = this._eventListeners.get(event);
+      if (listeners && listeners.length > 0) {
+        for (const listener of listeners) {
+          listener(...arguments_);
+          result = true;
+        }
+      }
+      if (event === this._errorEvent) {
+        const error = arguments_[0] instanceof Error ? arguments_[0] : new Error(`${arguments_[0]}`);
+        if (this._throwOnEmitError && !result) {
+          throw error;
+        } else {
+          if (this.listeners(this._errorEvent).length === 0 && this._throwOnEmptyListeners === true) {
+            throw error;
+          }
+        }
+      }
+      return result;
+    }
+    /**
+     * Gets all listeners for a specific event. If no event is provided, it returns all listeners
+     * @param {string} [event] (Optional) The event name
+     * @returns {EventListener[]} An array of listeners
+     */
+    listeners(event) {
+      return this._eventListeners.get(event) ?? [];
+    }
+    /**
+     * Removes all listeners for a specific event. If no event is provided, it removes all listeners
+     * @param {string} [event] (Optional) The event name
+     * @returns {IEventEmitter} returns the instance of the class for chaining
+     */
+    removeAllListeners(event) {
+      if (event !== void 0) {
+        this._eventListeners.delete(event);
+      } else {
+        this._eventListeners.clear();
+      }
+      return this;
+    }
+    /**
+     * Sets the maximum number of listeners that can be added for a single event
+     * @param {number} n The maximum number of listeners
+     * @returns {void}
+     */
+    setMaxListeners(n) {
+      this._maxListeners = n;
+      for (const listeners of this._eventListeners.values()) {
+        if (listeners.length > n) {
+          listeners.splice(n);
+        }
+      }
+    }
+    /**
+     * Gets all listeners
+     * @returns {EventListener[]} An array of listeners
+     */
+    getAllListeners() {
+      let result = [];
+      for (const listeners of this._eventListeners.values()) {
+        result = [...result, ...listeners];
+      }
+      return result;
+    }
+  };
+
+  // src/index.ts
+  var Hookified = class extends Eventified {
+    constructor(options) {
+      super({
+        logger: options?.logger,
+        throwOnEmitError: options?.throwOnEmitError,
+        throwOnEmptyListeners: options?.throwOnEmptyListeners
+      });
+      __publicField(this, "_hooks");
+      __publicField(this, "_throwOnHookError", false);
+      __publicField(this, "_enforceBeforeAfter", false);
+      __publicField(this, "_deprecatedHooks");
+      __publicField(this, "_allowDeprecated", true);
+      this._hooks = /* @__PURE__ */ new Map();
+      this._deprecatedHooks = options?.deprecatedHooks ? new Map(options.deprecatedHooks) : /* @__PURE__ */ new Map();
+      if (options?.throwOnHookError !== void 0) {
+        this._throwOnHookError = options.throwOnHookError;
+      } else if (options?.throwHookErrors !== void 0) {
+        this._throwOnHookError = options.throwHookErrors;
+      }
+      if (options?.enforceBeforeAfter !== void 0) {
+        this._enforceBeforeAfter = options.enforceBeforeAfter;
+      }
+      if (options?.allowDeprecated !== void 0) {
+        this._allowDeprecated = options.allowDeprecated;
+      }
+    }
+    /**
+     * Gets all hooks
+     * @returns {Map<string, Hook[]>}
+     */
+    get hooks() {
+      return this._hooks;
+    }
+    /**
+     * Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * @returns {boolean}
+     * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
+     */
+    get throwHookErrors() {
+      return this._throwOnHookError;
+    }
+    /**
+     * Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * @param {boolean} value
+     * @deprecated - this will be deprecated in version 2. Please use throwOnHookError.
+     */
+    set throwHookErrors(value) {
+      this._throwOnHookError = value;
+    }
+    /**
+     * Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * @returns {boolean}
+     */
+    get throwOnHookError() {
+      return this._throwOnHookError;
+    }
+    /**
+     * Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
+     * @param {boolean} value
+     */
+    set throwOnHookError(value) {
+      this._throwOnHookError = value;
+    }
+    /**
+     * Gets whether to enforce that all hook names start with 'before' or 'after'. Default is false.
+     * @returns {boolean}
+     * @default false
+     */
+    get enforceBeforeAfter() {
+      return this._enforceBeforeAfter;
+    }
+    /**
+     * Sets whether to enforce that all hook names start with 'before' or 'after'. Default is false.
+     * @param {boolean} value
+     */
+    set enforceBeforeAfter(value) {
+      this._enforceBeforeAfter = value;
+    }
+    /**
+     * Gets the map of deprecated hook names to deprecation messages.
+     * @returns {Map<string, string>}
+     */
+    get deprecatedHooks() {
+      return this._deprecatedHooks;
+    }
+    /**
+     * Sets the map of deprecated hook names to deprecation messages.
+     * @param {Map<string, string>} value
+     */
+    set deprecatedHooks(value) {
+      this._deprecatedHooks = value;
+    }
+    /**
+     * Gets whether deprecated hooks are allowed to be registered and executed. Default is true.
+     * @returns {boolean}
+     */
+    get allowDeprecated() {
+      return this._allowDeprecated;
+    }
+    /**
+     * Sets whether deprecated hooks are allowed to be registered and executed. Default is true.
+     * @param {boolean} value
+     */
+    set allowDeprecated(value) {
+      this._allowDeprecated = value;
+    }
+    /**
+     * Validates hook event name if enforceBeforeAfter is enabled
+     * @param {string} event - The event name to validate
+     * @throws {Error} If enforceBeforeAfter is true and event doesn't start with 'before' or 'after'
+     */
+    validateHookName(event) {
+      if (this._enforceBeforeAfter) {
+        const eventValue = event.trim().toLocaleLowerCase();
+        if (!eventValue.startsWith("before") && !eventValue.startsWith("after")) {
+          throw new Error(
+            `Hook event "${event}" must start with "before" or "after" when enforceBeforeAfter is enabled`
+          );
+        }
+      }
+    }
+    /**
+     * Checks if a hook is deprecated and emits a warning if it is
+     * @param {string} event - The event name to check
+     * @returns {boolean} - Returns true if the hook should proceed, false if it should be blocked
+     */
+    checkDeprecatedHook(event) {
+      if (this._deprecatedHooks.has(event)) {
+        const message = this._deprecatedHooks.get(event);
+        const warningMessage = `Hook "${event}" is deprecated${message ? `: ${message}` : ""}`;
+        this.emit("warn", { hook: event, message: warningMessage });
+        if (this.logger?.warn) {
+          this.logger.warn(warningMessage);
+        }
+        return this._allowDeprecated;
+      }
+      return true;
+    }
+    /**
+     * Adds a handler function for a specific event
+     * @param {string} event
+     * @param {Hook} handler - this can be async or sync
+     * @returns {void}
+     */
+    onHook(event, handler) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return;
+      }
+      const eventHandlers = this._hooks.get(event);
+      if (eventHandlers) {
+        eventHandlers.push(handler);
+      } else {
+        this._hooks.set(event, [handler]);
+      }
+    }
+    /**
+     * Adds a handler function for a specific event that runs before all other handlers
+     * @param {HookEntry} hookEntry
+     * @returns {void}
+     */
+    onHookEntry(hookEntry) {
+      this.onHook(hookEntry.event, hookEntry.handler);
+    }
+    /**
+     * Alias for onHook. This is provided for compatibility with other libraries that use the `addHook` method.
+     * @param {string} event
+     * @param {Hook} handler - this can be async or sync
+     * @returns {void}
+     */
+    addHook(event, handler) {
+      this.onHook(event, handler);
+    }
+    /**
+     * Adds a handler function for a specific event
+     * @param {Array<HookEntry>} hooks
+     * @returns {void}
+     */
+    onHooks(hooks) {
+      for (const hook of hooks) {
+        this.onHook(hook.event, hook.handler);
+      }
+    }
+    /**
+     * Adds a handler function for a specific event that runs before all other handlers
+     * @param {string} event
+     * @param {Hook} handler - this can be async or sync
+     * @returns {void}
+     */
+    prependHook(event, handler) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return;
+      }
+      const eventHandlers = this._hooks.get(event);
+      if (eventHandlers) {
+        eventHandlers.unshift(handler);
+      } else {
+        this._hooks.set(event, [handler]);
+      }
+    }
+    /**
+     * Adds a handler that only executes once for a specific event before all other handlers
+     * @param event
+     * @param handler
+     */
+    prependOnceHook(event, handler) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return;
+      }
+      const hook = async (...arguments_) => {
+        this.removeHook(event, hook);
+        return handler(...arguments_);
+      };
+      this.prependHook(event, hook);
+    }
+    /**
+     * Adds a handler that only executes once for a specific event
+     * @param event
+     * @param handler
+     */
+    onceHook(event, handler) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return;
+      }
+      const hook = async (...arguments_) => {
+        this.removeHook(event, hook);
+        return handler(...arguments_);
+      };
+      this.onHook(event, hook);
+    }
+    /**
+     * Removes a handler function for a specific event
+     * @param {string} event
+     * @param {Hook} handler
+     * @returns {void}
+     */
+    removeHook(event, handler) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return;
+      }
+      const eventHandlers = this._hooks.get(event);
+      if (eventHandlers) {
+        const index = eventHandlers.indexOf(handler);
+        if (index !== -1) {
+          eventHandlers.splice(index, 1);
+        }
+      }
+    }
+    /**
+     * Removes all handlers for a specific event
+     * @param {Array<HookEntry>} hooks
+     * @returns {void}
+     */
+    removeHooks(hooks) {
+      for (const hook of hooks) {
+        this.removeHook(hook.event, hook.handler);
+      }
+    }
+    /**
+     * Calls all handlers for a specific event
+     * @param {string} event
+     * @param {T[]} arguments_
+     * @returns {Promise<void>}
+     */
+    async hook(event, ...arguments_) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return;
+      }
+      const eventHandlers = this._hooks.get(event);
+      if (eventHandlers) {
+        for (const handler of eventHandlers) {
+          try {
+            await handler(...arguments_);
+          } catch (error) {
+            const message = `${event}: ${error.message}`;
+            this.emit("error", new Error(message));
+            if (this.logger) {
+              this.logger.error(message);
+            }
+            if (this._throwOnHookError) {
+              throw new Error(message);
+            }
+          }
+        }
+      }
+    }
+    /**
+     * Prepends the word `before` to your hook. Example is event is `test`, the before hook is `before:test`.
+     * @param {string} event - The event name
+     * @param {T[]} arguments_ - The arguments to pass to the hook
+     */
+    async beforeHook(event, ...arguments_) {
+      await this.hook(`before:${event}`, ...arguments_);
+    }
+    /**
+     * Prepends the word `after` to your hook. Example is event is `test`, the after hook is `after:test`.
+     * @param {string} event - The event name
+     * @param {T[]} arguments_ - The arguments to pass to the hook
+     */
+    async afterHook(event, ...arguments_) {
+      await this.hook(`after:${event}`, ...arguments_);
+    }
+    /**
+     * Calls all handlers for a specific event. This is an alias for `hook` and is provided for
+     * compatibility with other libraries that use the `callHook` method.
+     * @param {string} event
+     * @param {T[]} arguments_
+     * @returns {Promise<void>}
+     */
+    async callHook(event, ...arguments_) {
+      await this.hook(event, ...arguments_);
+    }
+    /**
+     * Gets all hooks for a specific event
+     * @param {string} event
+     * @returns {Hook[]}
+     */
+    getHooks(event) {
+      this.validateHookName(event);
+      if (!this.checkDeprecatedHook(event)) {
+        return void 0;
+      }
+      return this._hooks.get(event);
+    }
+    /**
+     * Removes all hooks
+     * @returns {void}
+     */
+    clearHooks() {
+      this._hooks.clear();
+    }
+  };
+})();
 //# sourceMappingURL=index.global.js.map