events-ex 2.1.0 → 2.2.0

package/lib/default-methods.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 exports.getEventableMethods = getEventableMethods;
 var _utilEx = require("util-ex");
+require("./util/promise-any");
 var _consts = require("./consts");
 var _event = require("./event");
 const create = Object.create;
@@ -17,6 +18,52 @@ function isRegExp(value) {
 }
 function getEventableMethods(aClass) {
   return {
+    /**
+     * Configures the event emitter with specified options using a Fluent API.
+     * @param {Object} options - Configuration options for event emission.
+     * @param {string} [options.asyncMode='serial'] - The mode of asynchronous emission ('serial' or 'parallel').
+     * @param {string} [options.resultMode='last'] - The strategy for handling multiple return values ('last', 'first', 'collect').
+     * @returns {import('./event-emitter').EventEmitter} A proxy object representing the configured EventEmitter.
+     */
+    configure(options) {
+      const proxy = Object.create(this);
+      const mergedOptions = Object.assign({}, this._eeRuntimeOptions, options);
+      (0, _utilEx.defineProperty)(proxy, '_eeRuntimeOptions', mergedOptions);
+      return proxy;
+    },
+    /**
+     * A shortcut for parallel configuration.
+     * @param {string} [resultMode='last'] - The strategy for handling multiple return values.
+     * @returns {import('./event-emitter').EventEmitter} A proxy object representing the configured EventEmitter.
+     */
+    parallel(resultMode) {
+      return this.configure({
+        asyncMode: 'parallel',
+        resultMode: resultMode || 'last'
+      });
+    },
+    /**
+     * Sets the configuration options for the EventEmitter instance.
+     * @param {Object} options - Configuration options for the emitter (e.g., asyncMode, resultMode, maxListeners).
+     * @returns {import('./event-emitter').EventEmitter} The EventEmitter instance for chaining.
+     */
+    setEmitterOptions(options) {
+      if (!(0, _utilEx.isObject)(options)) {
+        return this;
+      }
+      let data;
+      if (!this.hasOwnProperty('_emitterOptions')) {
+        data = create(null);
+        (0, _utilEx.defineProperty)(this, '_emitterOptions', data);
+      } else {
+        data = this._emitterOptions;
+      }
+      Object.assign(data, options);
+      if (!(0, _utilEx.isUndefined)(options.maxListeners) && (0, _utilEx.isFunction)(this.setMaxListeners)) {
+        this.setMaxListeners(options.maxListeners);
+      }
+      return this;
+    },
     /**
      * Adds a listener function to the specified event type.
      * @param {string|RegExp} type - The event type to listen for.
@@ -100,7 +147,7 @@ function getEventableMethods(aClass) {
      * @param {...*} args - The event type followed by any number of arguments to be passed to the listener functions.
      * @returns {*} The result of the event.
      */
-    emit( /* type, msg , ... */
+    emit(/* type, msg , ... */
     ) {
       const r = _emit.apply(this, arguments);
       if (!r) {
@@ -143,7 +190,7 @@ function getEventableMethods(aClass) {
      * @param {...*} args - The event type followed by any number of arguments to be passed to the listener functions.
      * @returns {Promise<*>} A promise that resolves with the result of the event.
      */
-    async emitAsync( /* type, msg , ... */
+    async emitAsync(/* type, msg , ... */
     ) {
       const r = _emit.apply(this, arguments);
       if (!r) {
@@ -152,27 +199,9 @@ function getEventableMethods(aClass) {
       const args = r.args;
       const listeners = r.listeners;
       const evt = (0, _event.Event)(this, r.type);
-      const errs = [];
+      const options = Object.assign({}, this._emitterOptions, this._eeRuntimeOptions);
       try {
-        for (const listener of listeners) {
-          try {
-            await _notify(listener, evt, args);
-            if (evt.stopped) {
-              break;
-            }
-          } catch (err) {
-            errs.push({
-              err: err,
-              listener: listener
-            });
-          }
-        }
-        if (errs.length) {
-          for (let i = 0; i < errs.length; i++) {
-            const it = errs[i];
-            this.emit('error', it.err, 'notify', r.type, it.listener, args);
-          }
-        }
+        await _executeAsync.call(this, listeners, evt, args, options);
       } finally {
         // eslint-disable-next-line no-unsafe-finally
         return evt.end();
@@ -420,4 +449,67 @@ function _notify(listener, evt, args) {
       }
   }
   return result;
+}
+async function _executeAsync(listeners, evt, args, options) {
+  const asyncMode = options.asyncMode || 'serial';
+  const resultMode = options.resultMode || 'last';
+  const errs = [];
+  if (resultMode === 'collect') {
+    evt.result = [];
+  }
+  const notifyListener = async listener => {
+    try {
+      const result = await _notify(listener, evt, args);
+      if (result !== undefined) {
+        if (resultMode === 'first' && !evt.resolved) {
+          evt.result = result;
+          evt.resolved = true;
+        } else if (resultMode === 'last') {
+          evt.result = result;
+        }
+      }
+      return result;
+    } catch (err) {
+      errs.push({
+        err,
+        listener
+      });
+      throw err;
+    }
+  };
+  if (asyncMode === 'parallel') {
+    const promises = listeners.map(listener => notifyListener(listener));
+    if (resultMode === 'collect') {
+      evt.result = await Promise.all(promises.map(p => p.catch(() => undefined)));
+    } else if (resultMode === 'first') {
+      try {
+        await Promise.any(promises.map(p => p.then(res => res === undefined ? Promise.reject() : res)));
+      } catch (e) {
+        // If all rejected or returned undefined, ignore
+      }
+    } else {
+      await Promise.all(promises.map(p => p.catch(() => undefined)));
+    }
+  } else {
+    // Serial mode (default)
+    for (const listener of listeners) {
+      try {
+        const result = await notifyListener(listener);
+        if (resultMode === 'collect') {
+          evt.result.push(result);
+        }
+        if (evt.stopped || resultMode === 'first' && evt.resolved) break;
+      } catch (err) {
+        if (resultMode === 'collect') {
+          evt.result.push(undefined);
+        }
+      }
+    }
+  }
+  if (errs.length) {
+    for (let i = 0; i < errs.length; i++) {
+      const it = errs[i];
+      this.emit('error', it.err, 'notify', evt.type, it.listener, args);
+    }
+  }
 }

package/lib/event-emitter.d.ts

@@ -28,8 +28,18 @@ export class EventEmitter {
    * @param {Function} listener - The listener function to be removed.
    * @returns {EventEmitter} The EventEmitter instance to allow chaining.
    * @throws {TypeError} If the listener is not a function.
+   * @see {@link removeListener}
    */
   off(eventName: string|RegExp, listener: ListenerCallbackFunc): EventEmitter;
+  /**
+   * Removes a listener function from the specified event type.
+   * @param {string|RegExp} type - The event type to remove the listener from.
+   * @param {Function} listener - The listener function to be removed.
+   * @returns {EventEmitter} The EventEmitter instance to allow chaining.
+   * @throws {TypeError} If the listener is not a function.
+   * @see {@link off}
+   */
+  removeListener(eventName: string|RegExp, listener: ListenerCallbackFunc): EventEmitter;
   /**
    * Emits the specified event type with the given arguments.
    * @param {...*} args - The event type followed by any number of arguments to be passed to the listener functions.
@@ -49,6 +59,13 @@ export class EventEmitter {
    * @returns {EventEmitter} - The event emitter with all listeners removed.
    */
   removeAllListeners(eventName?: string|RegExp): EventEmitter;
+  /**
+   * Sets the maximum number of listeners allowed for the event emitter.
+   *
+   * @param {number} n - The maximum number of listeners to set. Must be a positive integer.
+   * @returns {EventEmitter} The {@link EventEmitter} instance for method chaining.
+   * @throws {TypeError} If `n` is not a positive integer.
+   */
   setMaxListeners(n: number): EventEmitter;
   /**
    * Returns an array of functions that are registered to listen for the specified event.

package/lib/event.d.ts

@@ -5,7 +5,7 @@
  * @param {import('./event-emitter').EventEmitter} target - Who trigger the event
  * @returns {Event} - The new Event instance.
  */
-export function Event(target: import('./event-emitter').EventEmitter, type: any): Event;
+export function Event(target: import("./event-emitter").EventEmitter, type: any): Event;
 export class Event {
     /**
      * Creates a new Event object instance that contains information about the event, such as the target element and the return value of the event.
@@ -14,12 +14,12 @@ export class Event {
      * @param {import('./event-emitter').EventEmitter} target - Who trigger the event
      * @returns {Event} - The new Event instance.
      */
-    constructor(target: import('./event-emitter').EventEmitter, type: any);
+    constructor(target: import("./event-emitter").EventEmitter, type: any);
     /**
      * Initializes the event with the target object.
      * @param {import('./event-emitter').EventEmitter} target - The target object for the event.
      */
-    init(target: import('./event-emitter').EventEmitter, type: any): void;
+    init(target: import("./event-emitter").EventEmitter, type: any): void;
     /**
      * Who trigger the event
      * @type {Object}
@@ -32,6 +32,12 @@ export class Event {
      * @public
      */
     public stopped: boolean;
+    /**
+     * Whether a result has been resolved (for 'first' result mode)
+     * @type {boolean}
+     * @public
+     */
+    public resolved: boolean;
     /**
      * Keep your event result here if any.
      * @type {*}

package/lib/event.js

@@ -37,6 +37,12 @@ Event.prototype.init = function (target, type) {
    * @public
    */
   this.stopped = false;
+  /**
+   * Whether a result has been resolved (for 'first' result mode)
+   * @type {boolean}
+   * @public
+   */
+  this.resolved = false;
   /**
    * Keep your event result here if any.
    * @type {*}

package/lib/eventable.js

@@ -7,7 +7,7 @@ exports.eventable = exports.default = void 0;
 var _customAbility = require("custom-ability");
 var _defineProperty = _interopRequireDefault(require("util-ex/lib/defineProperty"));
 var _defaultMethods = _interopRequireDefault(require("./default-methods"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Creates an Eventable class with event-emitting capabilities.
  *
@@ -31,6 +31,9 @@ function getEventableClass(aClass) {
   Eventable.prototype.listenerCount = methods.listenerCount;
   Eventable.prototype.emit = methods.emit;
   Eventable.prototype.emitAsync = methods.emitAsync;
+  Eventable.prototype.configure = methods.configure;
+  Eventable.prototype.parallel = methods.parallel;
+  Eventable.prototype.setEmitterOptions = methods.setEmitterOptions;
   Eventable.prototype.on = methods.on;
   Eventable.prototype.addListener = methods.on;
   Eventable.prototype.off = methods.off;

package/lib/pipe-async.d.ts

@@ -4,8 +4,11 @@
  * @param {import('./event-emitter').EventEmitter} e1 - The first event emitter.
  * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter.
  * @param {string} [name='emitAsync'] - The name of the event to pipe (defaults to 'emitAsync').
+ * @param {Object} [options] - Configuration for the pipeline.
+ * @param {string} [options.asyncMode='serial'] - The mode of propagation ('serial' or 'parallel').
+ * @param {string} [options.resultMode] - Strategy for aggregating results from the pipe chain ('collect', 'first').
  * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-export function pipeAsync(e1: import('./event-emitter').EventEmitter, e2: import('./event-emitter').EventEmitter, ...args: any[]): any;
+export function pipeAsync(e1: import("./event-emitter").EventEmitter, e2: import("./event-emitter").EventEmitter, ...args: any[]): any;
 export default pipeAsync;

package/lib/pipe-async.js

@@ -9,7 +9,7 @@ var _defineProperty = _interopRequireDefault(require("util-ex/lib/defineProperty
 var _wrapEventEmitter = require("./wrap-event-emitter");
 var _arrayRemove = _interopRequireDefault(require("./util/array-remove"));
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 const arrFrom = Array.from;
@@ -21,16 +21,27 @@ const emit = _wrapEventEmitter.methods.emitAsync;
  * @param {import('./event-emitter').EventEmitter} e1 - The first event emitter.
  * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter.
  * @param {string} [name='emitAsync'] - The name of the event to pipe (defaults to 'emitAsync').
+ * @param {Object} [options] - Configuration for the pipeline.
+ * @param {string} [options.asyncMode='serial'] - The mode of propagation ('serial' or 'parallel').
+ * @param {string} [options.resultMode] - Strategy for aggregating results from the pipe chain ('collect', 'first').
  * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-function pipeAsync(e1, e2 /* , name */) {
+function pipeAsync(e1, e2 /* , name, options */) {
   let pipes;
   (0, _validObject.default)(e1) && (0, _validObject.default)(e2);
   let name = arguments[2];
+  let options = arguments[3];
+  if (typeof name === 'object') {
+    options = name;
+    name = undefined;
+  }
   if (name === undefined) {
     name = 'emitAsync';
   }
+  if (!options) {
+    options = {};
+  }
   const result = {
     close() {
       _arrayRemove.default.call(pipes, e2);
@@ -50,9 +61,32 @@ function pipeAsync(e1, e2 /* , name */) {
   }
   desc.value = async function () {
     const data = arrFrom(pipes);
-    await emit.apply(this, arguments);
-    let emitter;
-    for (let i = 0; emitter = data[i]; ++i) await emit.apply(emitter, arguments);
+    const asyncMode = options.asyncMode || 'serial';
+    const resultMode = options.resultMode;
+    const forward = async (target, args) => {
+      const fn = target[name] || target.emitAsync || emit;
+      return fn.apply(target, args);
+    };
+    if (asyncMode === 'parallel') {
+      const promises = [emit.apply(this, arguments)];
+      for (let i = 0; i < data.length; ++i) {
+        promises.push(forward(data[i], arguments));
+      }
+      const results = await Promise.all(promises);
+      if (resultMode === 'collect') return results;
+      if (resultMode === 'first') return results.find(r => r !== undefined);
+      return results[0]; // Default: return main emitter's result
+    } else {
+      const mainResult = await emit.apply(this, arguments);
+      const allResults = [mainResult];
+      for (let i = 0; i < data.length; ++i) {
+        const res = await forward(data[i], arguments);
+        allResults.push(res);
+      }
+      if (resultMode === 'collect') return allResults;
+      if (resultMode === 'first') return allResults.find(r => r !== undefined);
+      return mainResult; // Default: return main emitter's result
+    }
   };
   (0, _defineProperty.default)(e1, name, desc.value, desc);
   return result;

package/lib/pipe.d.ts

@@ -7,5 +7,5 @@
  * @returns {Object} - An object with a `close` method that removes the pipeline between the two event emitters.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-export function pipe(e1: import('./event-emitter').EventEmitter, e2: import('./event-emitter').EventEmitter, ...args: any[]): any;
+export function pipe(e1: import("./event-emitter").EventEmitter, e2: import("./event-emitter").EventEmitter, ...args: any[]): any;
 export default pipe;

package/lib/pipe.js

@@ -9,7 +9,7 @@ var _defineProperty = _interopRequireDefault(require("util-ex/lib/defineProperty
 var _wrapEventEmitter = require("./wrap-event-emitter");
 var _arrayRemove = _interopRequireDefault(require("./util/array-remove"));
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
 const arrFrom = Array.from;

package/lib/unify.d.ts

@@ -5,5 +5,5 @@
  * @param {import('./event-emitter').EventEmitter} e2 - The second event emitter object.
  * @throws {TypeError} - If either of the arguments is not an event emitter object.
  */
-export function unify(e1: import('./event-emitter').EventEmitter, e2: import('./event-emitter').EventEmitter): void;
+export function unify(e1: import("./event-emitter").EventEmitter, e2: import("./event-emitter").EventEmitter): void;
 export default unify;

package/lib/unify.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 exports.unify = unify;
 var _validObject = _interopRequireDefault(require("./util/valid-object"));
 var _objectForEach = _interopRequireDefault(require("./util/object-for-each"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const push = Array.prototype.apply;
 const defineProperty = Object.defineProperty;
 const create = Object.create;

package/lib/util/array-remove.js

@@ -8,7 +8,7 @@ exports.remove = remove;
 const indexOf = Array.prototype.indexOf;
 const forEach = Array.prototype.forEach;
 const splice = Array.prototype.splice;
-function remove( /* ...itemsToRemove */
+function remove(/* ...itemsToRemove */
 ) {
   forEach.call(arguments, function (item) {
     const index = indexOf.call(this, item);

package/lib/util/object-for-each.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 exports.forEach = forEach;
 var _validObject = _interopRequireDefault(require("./valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const bind = Function.prototype.bind;
 const keys = Object.keys;
 function forEach(obj, cb /* , thisArg, compareFn */) {

package/lib/util/promise-any.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/util/promise-any.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+/**
+ * Simple polyfill for AggregateError if it doesn't exist.
+ */
+const _AggregateError = typeof AggregateError !== 'undefined' ? AggregateError : function AggregateError(errors, message) {
+  const error = new Error(message);
+  error.name = 'AggregateError';
+  error.errors = errors;
+  return error;
+};
+
+/**
+ * Ensures Promise.any exists, or provides a polyfill.
+ */
+if (typeof Promise.any !== 'function') {
+  Promise.any = function (promises) {
+    return new Promise((resolve, reject) => {
+      promises = Array.from(promises);
+      const len = promises.length;
+      let errors = [];
+      let rejectedCount = 0;
+      if (len === 0) {
+        return reject(new _AggregateError(errors, 'All promises were rejected'));
+      }
+      promises.forEach((promise, index) => {
+        Promise.resolve(promise).then(value => {
+          resolve(value);
+        }).catch(error => {
+          errors[index] = error;
+          rejectedCount++;
+          if (rejectedCount === len) {
+            reject(new _AggregateError(errors, 'All promises were rejected'));
+          }
+        });
+      });
+    });
+  };
+}
+var _default = exports.default = Promise.any;

package/lib/util/string-pad.js

@@ -7,7 +7,7 @@ exports.default = void 0;
 exports.pad = pad;
 var _toInt = _interopRequireDefault(require("./to-int"));
 var _validObject = _interopRequireDefault(require("./valid-object"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const repeat = String.prototype.repeat;
 const abs = Math.abs;
 const max = Math.max;

package/lib/wrap-event-emitter.d.ts

@@ -1,8 +1,9 @@
 /**
  * Create or inject the eventable instance into the object
  * @param {Object} [o] the optional instance to eventable
+ * @param {Object} [options] optional configuration for the emitter
  * @returns o or new Event instance
  */
-export function wrapEventEmitter(o?: any): any;
+export function wrapEventEmitter(o?: any, options?: any): any;
 export const methods: any;
 export default wrapEventEmitter;

package/lib/wrap-event-emitter.js

@@ -7,10 +7,14 @@ exports.methods = exports.default = void 0;
 exports.wrapEventEmitter = wrapEventEmitter;
 var _utilEx = require("util-ex");
 var _eventable = _interopRequireDefault(require("./eventable"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 const create = Object.create;
 const defineProperties = Object.defineProperties;
 const methods = exports.methods = (0, _eventable.default)().methods;
+
+/**
+ * Minimal set of core methods to be injected into an existing object.
+ */
 const descriptors = {
   on: {
     value: methods.on
@@ -26,18 +30,35 @@ const descriptors = {
   },
   emitAsync: {
     value: methods.emitAsync
+  },
+  setEmitterOptions: {
+    value: methods.setEmitterOptions
   }
 };
-const base = defineProperties({}, descriptors);
+
+/**
+ * Full set of all available methods from eventable for standalone instances.
+ */
+const fullDescriptors = {};
+Object.keys(methods).forEach(key => {
+  fullDescriptors[key] = {
+    value: methods[key]
+  };
+});
+const base = defineProperties({}, fullDescriptors);
 
 /**
  * Create or inject the eventable instance into the object
  * @param {Object} [o] the optional instance to eventable
+ * @param {Object} [options] optional configuration for the emitter
  * @returns o or new Event instance
  */
-function wrapEventEmitter(o) {
+function wrapEventEmitter(o, options) {
   const result = o == null ? create(base) : defineProperties(Object(o), descriptors);
   (0, _utilEx.defineProperty)(result, '_events', {});
+  if (options && options.emitterOptions) {
+    result.setEmitterOptions(options.emitterOptions);
+  }
   return result;
 }
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "events-ex",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Browser-friendly enhanced events most compatible with standard node.js, it's powerful eventable ability.",
   "contributors": [
     {
@@ -37,25 +37,25 @@
   "main": "./lib/index.js",
   "module": "./src/index.js",
   "dependencies": {
-    "custom-ability": "^2.0.1",
-    "util-ex": "^2.0.0"
+    "custom-ability": "^2.1.0",
+    "util-ex": "^2.5.1"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^2.6.1",
-    "@babel/cli": "^7.23.4",
-    "@babel/core": "^7.23.7",
+    "@antfu/eslint-config": "^7.7.0",
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.29.0",
     "@babel/plugin-proposal-dynamic-import": "^7.18.6",
-    "@babel/plugin-transform-modules-commonjs": "^7.23.3",
-    "@babel/register": "^7.23.7",
-    "chai": "~4.3.7",
-    "eslint": "^8.56.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-tsdoc": "^0.2.17",
-    "mocha": "^10.6.0",
-    "prettier": "^3.1.1",
-    "typedoc": "^0.25.4",
-    "typedoc-plugin-markdown": "^3.17.1",
-    "typescript": "^5.3.3"
+    "@babel/plugin-transform-modules-commonjs": "^7.28.6",
+    "@babel/register": "^7.28.6",
+    "chai": "~4.3.10",
+    "eslint": "^10.0.3",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-tsdoc": "^0.5.2",
+    "mocha": "^11.7.5",
+    "prettier": "^3.8.1",
+    "typedoc": "^0.28.17",
+    "typedoc-plugin-markdown": "^4.10.0",
+    "typescript": "~5.7.3"
   },
   "scripts": {
     "build": "npm run build.cjs && npm run build.ts && npm run doc.md",