@tstdl/base 0.93.34 → 0.93.36

package/source/utils/iterable-helpers/single-or-default.ts

@@ -0,0 +1,22 @@
+import type { Predicate, TypePredicate } from './types.js';
+
+export function singleOrDefault<T, D, TPredicate extends T = T>(iterable: Iterable<T>, defaultValue: D, predicate: TypePredicate<T, TPredicate> | Predicate<T> = (() => true)): TPredicate | D {
+  let matched = false;
+  let result: TPredicate | D = defaultValue;
+  let index = 0;
+
+  for (const item of iterable) {
+    const matches = predicate(item, index++);
+
+    if (matches) {
+      if (matched) {
+        throw new Error('more than one item matched predicate');
+      }
+
+      matched = true;
+      result = item as TPredicate;
+    }
+  }
+
+  return result;
+}

package/source/utils/iterable-helpers/single.ts

@@ -0,0 +1,26 @@
+import type { Predicate, TypePredicate } from './types.js';
+
+export function single<T, TPredicate extends T = T>(iterable: Iterable<T>, predicate: TypePredicate<T, TPredicate> | Predicate<T> = (() => true)): TPredicate {
+  let matched = false;
+  let result: T | undefined;
+  let index = 0;
+
+  for (const item of iterable) {
+    const matches = predicate(item, index++);
+
+    if (matches) {
+      if (matched) {
+        throw new Error('more than one item matched predicate');
+      }
+
+      matched = true;
+      result = item;
+    }
+  }
+
+  if (!matched) {
+    throw new Error('no item matched predicate');
+  }
+
+  return result as TPredicate;
+}

package/source/utils/iterable-helpers/skip.ts

@@ -0,0 +1,8 @@
+export function* skip<T>(iterable: Iterable<T>, count: number): IterableIterator<T> {
+  let index = 0;
+  for (const item of iterable) {
+    if (index++ >= count) {
+      yield item;
+    }
+  }
+}

package/source/utils/iterable-helpers/sort.ts

@@ -0,0 +1,7 @@
+import { compareByValue } from '../comparison.js';
+import type { Comparator } from '../sort.js';
+
+export function sort<T>(iterable: Iterable<T>, comparator: Comparator<T> = compareByValue): T[] {
+  const array = [...iterable];
+  return array.sort(comparator);
+}

package/source/utils/iterable-helpers/take-until.ts

@@ -0,0 +1,15 @@
+import type { CancellationSignal } from '#/cancellation/token.js';
+
+export function* takeUntil<T>(iterable: Iterable<T>, cancellationSignal: CancellationSignal): IterableIterator<T> {
+  const iterator = iterable[Symbol.iterator]();
+
+  while (cancellationSignal.isUnset) {
+    const result = iterator.next();
+
+    if (result.done == true) {
+      return;
+    }
+
+    yield result.value;
+  }
+}

package/source/utils/iterable-helpers/take-while.ts

@@ -0,0 +1,16 @@
+import type { Predicate } from './types.js';
+
+export function* takeWhile<T>(iterable: Iterable<T>, yieldLastOnFalse: boolean, predicate: Predicate<T>): IterableIterator<T> {
+  let index = 0;
+  for (const item of iterable) {
+    const take = predicate(item, index++);
+
+    if (take || yieldLastOnFalse) {
+      yield item;
+    }
+
+    if (!take) {
+      break;
+    }
+  }
+}

package/source/utils/iterable-helpers/take.ts

@@ -0,0 +1,14 @@
+export function* take<T>(iterable: Iterable<T>, count: number): IterableIterator<T> {
+  if (count <= 0) {
+    return;
+  }
+
+  let counter = 0;
+  for (const item of iterable) {
+    yield item;
+
+    if (++counter >= count) {
+      break;
+    }
+  }
+}

package/source/utils/iterable-helpers/tap.ts

@@ -0,0 +1,10 @@
+import type { IteratorFunction } from './types.js';
+
+export function* tap<T>(iterable: Iterable<T>, tapper: IteratorFunction<T, any>): IterableIterator<T> {
+  let index = 0;
+
+  for (const item of iterable) {
+    tapper(item, index++);
+    yield item;
+  }
+}

package/source/utils/iterable-helpers/types.ts

@@ -0,0 +1,7 @@
+export type Context<T> = { item: T, readonly index: number };
+export type TypePredicate<T, TPredicate extends T> = (item: T, index: number) => item is TPredicate;
+export type Predicate<T> = (item: T, index: number) => boolean;
+export type IteratorFunction<TIn, TOut> = (item: TIn, index: number) => TOut;
+export type Reducer<T, U> = (previous: U, current: T, index: number) => U;
+export type IterableItemMetadata<T> = { index: number, isFirst: boolean, isLast: boolean, value: T };
+export type GroupSelectors<T, TGroup extends any[]> = { [P in keyof TGroup]: IteratorFunction<T, TGroup[P]> };

package/source/utils/iterable-helpers/while.ts

@@ -0,0 +1,15 @@
+import type { Predicate } from './types.js';
+
+export function* whileSync<T>(iterable: Iterable<T>, predicate: Predicate<T>): IterableIterator<T> {
+  let index = 0;
+
+  for (const item of iterable) {
+    yield item;
+
+    const goOn = predicate(item, index++);
+
+    if (!goOn) {
+      return;
+    }
+  }
+}

package/source/utils/jwt.ts

@@ -0,0 +1,145 @@
+import type { BinaryData, OneOrMany, Record } from '#/types/index.js';
+import { InvalidTokenError } from '../errors/invalid-token.error.js';
+import { toArray } from './array/array.js';
+import { decodeBase64Url, encodeBase64Url } from './base64.js';
+import type { HashAlgorithm, Key } from './cryptography.js';
+import { importHmacKey, sign } from './cryptography.js';
+import { encodeUtf8 } from './encoding.js';
+import { timingSafeBinaryEquals } from './equals.js';
+
+export type JwtTokenAlgorithm = 'HS256' | 'HS384' | 'HS512';
+
+export type JwtTokenHeader<T extends Record<string> = Record<string>> = {
+  alg: JwtTokenAlgorithm,
+  typ: 'JWT',
+} & T;
+
+export type JwtToken<TPayload = Record<string>, THeader extends JwtTokenHeader = JwtTokenHeader> = {
+  readonly header: THeader,
+  readonly payload: TPayload,
+};
+
+export type JwtTokenParseResult<T extends JwtToken = JwtToken> = {
+  raw: string,
+  token: T,
+  encoded: {
+    header: string,
+    payload: string,
+    signature: string,
+  },
+  bytes: {
+    header: Uint8Array<ArrayBuffer>,
+    payload: Uint8Array<ArrayBuffer>,
+    signature: Uint8Array<ArrayBuffer>,
+  },
+  string: {
+    header: string,
+    payload: string,
+  },
+};
+
+export function parseJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string): JwtTokenParseResult<T> {
+  const splits = tokenString.split('.');
+
+  if (splits.length != 3) {
+    const message = (tokenString.length > 0) ? 'Invalid token format' : 'Missing authorization token';
+    throw new InvalidTokenError(message);
+  }
+
+  const [encodedHeader, encodedPayload, encodedSignature] = splits;
+
+  const textDecoder = new TextDecoder();
+
+  const encoded: JwtTokenParseResult['encoded'] = {
+    header: encodedHeader!,
+    payload: encodedPayload!,
+    signature: encodedSignature!,
+  };
+
+  const bytes: JwtTokenParseResult['bytes'] = {
+    header: decodeBase64Url(encodedHeader!),
+    payload: decodeBase64Url(encodedPayload!),
+    signature: decodeBase64Url(encodedSignature!),
+  };
+
+  const string: JwtTokenParseResult['string'] = {
+    header: textDecoder.decode(bytes.header),
+    payload: textDecoder.decode(bytes.payload),
+  };
+
+  try {
+    const header = JSON.parse(string.header) as T['header'];
+    const payload = JSON.parse(string.payload) as T['payload'];
+
+    const token: JwtToken = {
+      header,
+      payload,
+    };
+
+    return {
+      raw: tokenString,
+      token: token as T,
+      encoded,
+      bytes,
+      string,
+    };
+  }
+  catch {
+    throw new InvalidTokenError('Invalid token format');
+  }
+}
+
+export async function createJwtTokenString(jwtToken: JwtToken, key: Key | string): Promise<string> {
+  const headerBuffer = encodeUtf8(JSON.stringify(jwtToken.header));
+  const payloadBuffer = encodeUtf8(JSON.stringify(jwtToken.payload));
+
+  const encodedHeader = encodeBase64Url(headerBuffer, 0, headerBuffer.byteLength);
+  const encodedPayload = encodeBase64Url(payloadBuffer, 0, payloadBuffer.byteLength);
+
+  const headerPayloadDataString = `${encodedHeader}.${encodedPayload}`;
+  const headerPayloadData = encodeUtf8(headerPayloadDataString);
+
+  const signature = await getSignature(headerPayloadData, jwtToken.header.alg, key);
+  const encodedSignature = encodeBase64Url(signature);
+
+  const tokenString = `${headerPayloadDataString}.${encodedSignature}`;
+  return tokenString;
+}
+
+export async function parseAndValidateJwtTokenString<T extends JwtToken = JwtToken>(tokenString: string, allowedAlgorithms: OneOrMany<JwtTokenAlgorithm>, key: Key | string): Promise<T> {
+  try {
+    const { encoded, bytes, token } = parseJwtTokenString<T>(tokenString);
+
+    if (!toArray(allowedAlgorithms).includes(token.header.alg)) {
+      throw new InvalidTokenError('Invalid signature algorithm');
+    }
+
+    const calculatedSignature = await getSignature(encodeUtf8(`${encoded.header}.${encoded.payload}`), token.header.alg, key);
+    const validSignature = timingSafeBinaryEquals(bytes.signature, calculatedSignature);
+
+    if (!validSignature) {
+      throw new InvalidTokenError('Invalid token signature');
+    }
+
+    return token;
+  }
+  catch (error: unknown) {
+    if (error instanceof InvalidTokenError) {
+      throw error;
+    }
+
+    throw new InvalidTokenError('Invalid token');
+  }
+}
+
+async function getSignature(data: BinaryData<ArrayBuffer>, algorithm: JwtTokenAlgorithm, secret: Key | string): Promise<ArrayBuffer> {
+  const hashAlgorithm = getHmacHashAlgorithm(algorithm);
+  const hmacKey = await importHmacKey(hashAlgorithm, secret, false);
+  const hmacSignature = sign('HMAC', hmacKey, data);
+
+  return await hmacSignature.toBuffer();
+}
+
+function getHmacHashAlgorithm(algorithm: JwtTokenAlgorithm): HashAlgorithm {
+  return algorithm.replace('HS', 'SHA-') as HashAlgorithm;
+}

package/source/utils/map.ts

@@ -0,0 +1,59 @@
+import { compareByValueSelectionDescending } from './comparison.js';
+
+export function intersectMaps<K, V>(...maps: Map<K, V>[]): [K, V][] {
+  if (maps.length == 0) {
+    return [];
+  }
+
+  if (maps.length == 1) {
+    return [...maps[0]!];
+  }
+
+  const sortedMaps = maps.sort(compareByValueSelectionDescending((map) => map.size));
+  const [smallestMap, ...otherMaps] = sortedMaps;
+
+  return [...smallestMap!].filter((entry) => !otherMaps.some((map) => !map.has(entry[0])));
+}
+
+export function differenceMaps<K, V>(base: Map<K, V>, ...maps: Map<K, V>[]): [K, V][] {
+  return [...base].filter((entry) => !maps.some((map) => map.has(entry[0])));
+}
+
+export function symmetricDifferenceMaps<K, V>(...maps: Map<K, V>[]): Map<K, V> {
+  if (maps.length == 0) {
+    return new Map();
+  }
+
+  if (maps.length == 1) {
+    return maps[0]!;
+  }
+
+  const [first, second, ...others] = maps;
+
+
+  return symmetricDifferenceMaps(simpleSymmetricDifference(first!, second!), ...others);
+}
+
+export function uniquesMaps<K, V>(...maps: Map<K, V>[]): Map<K, V> {
+  const result = new Map<K, V>();
+
+  for (const map of maps) {
+    for (const entry of map) {
+      const unique = maps.every((otherMap) => (map == otherMap) || !otherMap.has(entry[0]));
+
+      if (unique) {
+        result.set(entry[0], entry[1]);
+      }
+    }
+  }
+
+  return result;
+}
+
+export function unionMaps<K, V>(...maps: Iterable<[K, V]>[]): Map<K, V> {
+  return new Map(maps.flatMap((map) => [...map]));
+}
+
+function simpleSymmetricDifference<K, V>(a: Map<K, V>, b: Map<K, V>): Map<K, V> {
+  return unionMaps(differenceMaps(a, b), differenceMaps(b, a));
+}

package/source/utils/math.ts

@@ -0,0 +1,159 @@
+import { defaultRandomNumberGeneratorFn, type RandomNumberGeneratorFn } from '#/random/number-generator/random-number-generator-function.js';
+import { isNull } from './type-guards.js';
+
+/**
+ * Generate a random float in interval [min, max).
+ * @param min minimum value
+ * @param max maximum value
+ * @param generator Random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1).
+ * @returns random number (float)
+ */
+export function randomFloat(min: number, max: number, generator: RandomNumberGeneratorFn = defaultRandomNumberGeneratorFn): number {
+  return linearInterpolateFloat(generator(), min, max);
+}
+
+/**
+ * Generate a random integer in interval [min, max].
+ * @param min minimum value
+ * @param max maximum value
+ * @param generator random number generator to use, defaults to `Math.random`. Must return a number in interval [0, 1)
+ * @returns random number (integer)
+ */
+export function randomInt(min: number, max: number, generator: RandomNumberGeneratorFn = defaultRandomNumberGeneratorFn): number {
+  return Math.floor(linearInterpolateFloat(generator(), min, max + 1));
+}
+
+/**
+ * Calculate the sum of all values.
+ * @param values values to sum
+ * @returns sum
+ */
+export function sum(values: number[]): number {
+  return values.reduce((previous, current) => previous + current, 0);
+}
+
+/**
+ * Calculate the average of all values.
+ * @param values values to average
+ * @returns average
+ */
+export function average(values: number[]): number {
+  return sum(values) / values.length;
+}
+
+/**
+ * Calculate the minimum value.
+ * @param values values to get minimum from
+ * @returns minimum
+ */
+export function minimum(values: number[]): number {
+  if (values.length == 0) {
+    throw new Error('No values provided.');
+  }
+
+  return values.reduce((previous, current) => Math.min(previous, current), Number.POSITIVE_INFINITY);
+}
+
+/**
+ * Calculate the maximum value.
+ * @param values values to get maximum from
+ * @returns maximum
+ */
+export function maximum(values: number[]): number {
+  if (values.length == 0) {
+    throw new Error('No values provided.');
+  }
+
+  return values.reduce((previous, current) => Math.max(previous, current), Number.NEGATIVE_INFINITY);
+}
+
+/**
+ * Round number to specified decimals.
+ * @param value value to round
+ * @param decimals number of decimals to round to
+ * @returns rounded number
+ */
+export function round(value: number, decimals: number): number {
+  const factor = 10 ** decimals;
+  return Math.round((value + Number.EPSILON) * factor) / factor;
+}
+
+/**
+ * Linearly interpolate the interval [fromLow, fromHigh] into [toLow, toHigh].
+ * @param value value to interpolate
+ * @param fromLow source lower bound
+ * @param fromHigh source upper bound
+ * @param toLow target lower bound
+ * @param toHigh target upper bound
+ * @returns interpolated value
+ */
+export function linearInterpolate(value: number, fromLow: number, fromHigh: number, toLow: number, toHigh: number): number {
+  return toLow + ((value - fromLow) * (toHigh - toLow) / (fromHigh - fromLow));
+}
+
+/**
+ * Linearly interpolate [0, 1] into an interval.
+ * @param value value to interpolate in interval [0, 1]
+ * @param low lower bound
+ * @param high upper bound
+ * @returns interpolated value
+ */
+export function linearInterpolateFloat(value: number, low: number, high: number): number {
+  return ((1 - value) * low) + (value * high);
+}
+
+/**
+ * Clamps a number between two numbers.
+ * @param value value to clamp
+ * @param minimum lower bound
+ * @param maximum upper bound
+ * @returns clamped value
+ */
+export function clamp(value: number, minimum: number, maximum: number): number {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+
+/**
+ * Calculates the nth-root of a number.
+ *
+ * Warning: negative values are handled as if they were positive but returned with an negative sign.
+ * @param base base
+ * @param root root
+ * @returns nth-root of base
+ */
+export function nthRoot(base: number, root: number): number {
+  return (base < 0) ? -((-base) ** (1 / root)) : (base ** (1 / root));
+}
+
+/**
+ *
+ * @param t Time in interval [0, 1]
+ * @param attenuationExponentStart Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param attenuationExponentEnd Sensible values are between 1 (linear attenuation) and ~10 (no attenuation until t = ~0.9, then sharply increasing attenuation)
+ * @param deadzoneWidthStart Deadzone width to add in front of 0.5. Sensible values are between 0 and 0.5
+ * @param deadzoneWidthEnd Deadzone width to add to interval [0.5, 1]. Sensible values are between 0 and 0.5
+ * @returns Coefficient in interval [0, 1]
+ */
+export function getAttenuationCoefficient(t: number, attenuationExponentStart: number | null, attenuationExponentEnd: number | null, deadzoneWidthStart: number = 0, deadzoneWidthEnd: number = 0): number {
+  if ((t < 0) || (t > 1)) {
+    return 0;
+  }
+
+  if (t <= 0.5) {
+    if (isNull(attenuationExponentStart)) {
+      return 1;
+    }
+
+    if (t >= (0.5 - deadzoneWidthStart)) {
+      return 1;
+    }
+
+    return 1 - (-2 * (t - (0.5 - deadzoneWidthStart)) * (0.5 / (0.5 - deadzoneWidthStart))) ** (attenuationExponentStart ** 1.5);
+  }
+
+  if (isNull(attenuationExponentEnd) || (t <= (0.5 + deadzoneWidthEnd))) {
+    return 1;
+  }
+
+  return 1 - (-2 * (-(t - 1) - (0.5 - deadzoneWidthEnd)) * (0.5 / (0.5 - deadzoneWidthEnd))) ** (attenuationExponentEnd ** 1.5);
+}

package/source/utils/merge.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+
+import type { IsEqual, MergeDeep, MergeDeepOptions as TypeFestMergeDeepOptions } from 'type-fest';
+
+import type { If, Merge, Record, TypedOmit } from '#/types/index.js';
+import { createArray } from './array/array.js';
+import { objectEntries } from './object/object.js';
+import { assertArray, assertLiteralObject, assertMap, assertSet, isArray, isLiteralObject, isMap, isSet, isUndefined } from './type-guards.js';
+
+type BaseType = Record | any[] | Map<any, any> | Set<any>;
+
+export function merge<A extends BaseType, B extends BaseType>(a: A | undefined, b: B | undefined):
+  A extends (infer T)[] ? B extends (infer U)[] ? (T | U)[] : never
+  : A extends Map<infer K, infer V> ? B extends Map<infer K2, infer V2> ? Map<K | K2, V | V2> : never
+  : A extends Set<infer T> ? B extends Set<infer U> ? Set<T | U> : never
+  : A extends Record ? B extends Record ? Merge<A, B> : never
+  : never {
+  if (isUndefined(a)) {
+    return b as any;
+  }
+
+  if (isUndefined(b)) {
+    return a as any;
+  }
+
+  if (isLiteralObject(a)) {
+    assertLiteralObject(b, 'Cannot merge object into non-object.');
+    return { ...a, ...b } as any;
+  }
+  else if (isArray(a)) {
+    assertArray(b, 'Cannot merge array into non-array.');
+    return [...a, ...b] as any;
+  }
+  else if (isMap(a)) {
+    assertMap(b, 'Cannot merge map into non-map.');
+    return new Map([...a, ...b]) as any;
+  }
+  else if (isSet(a)) {
+    assertSet(b, 'Cannot merge set into non-set.');
+    return new Set([...a, ...b]) as any;
+  }
+
+  throw new Error('Merging of data can only be done with objects, arrays, maps and sets.');
+}
+
+export type MergeDeepOptions = TypedOmit<TypeFestMergeDeepOptions, 'arrayMergeMode'> & { arrayMergeMode?: TypeFestMergeDeepOptions['arrayMergeMode'] | 'mergeItems' };
+
+export function mergeDeep<A extends Record, B extends Record, Options extends MergeDeepOptions = { arrayMergeMode: 'spread', recurseIntoArrays: true }>(a: A, b: B, options?: Options): MergeDeep<A, B, { arrayMergeMode: If<IsEqual<Options['arrayMergeMode'], 'mergeItems'>, 'spread', Exclude<Options['arrayMergeMode'], 'mergeItems'>>, recurseIntoArrays: Options['recurseIntoArrays'] }> {
+  const { arrayMergeMode = 'spread', recurseIntoArrays = true } = options ?? {};
+
+  const result = { ...a };
+
+  for (const [key, value] of objectEntries(b)) {
+    if (isLiteralObject(a[key]) && isLiteralObject(value)) {
+      result[key] = mergeDeep(a[key], value) as any;
+    }
+    else if (recurseIntoArrays && isArray(a[key]) && isArray(value)) {
+      result[key] = mergeArray(a[key], value, arrayMergeMode) as any;
+    }
+    else {
+      result[key] = value;
+    }
+  }
+
+  return result as any;
+}
+
+export function mergeArray<A extends readonly any[], B extends readonly any[], Mode extends NonNullable<MergeDeepOptions['arrayMergeMode']>>(a: A, b: B, mode: Mode): MergeDeep<A, B, { recurseIntoArrays: true, arrayMergeMode: If<IsEqual<Mode, 'mergeItems'>, 'spread', Exclude<Mode, 'mergeItems'>> }> {
+  if (mode == 'spread') {
+    return [...a, ...b] as any;
+  }
+
+  const length = Math.max(a.length, b.length);
+
+  if (mode == 'replace') {
+    return createArray(length, (index) => b[index] ?? a[index]) as any;
+  }
+
+  return createArray(length, (index) => {
+    if (isLiteralObject(a[index]) && isLiteralObject(b[index])) {
+      return mergeDeep(a[index], b[index], { arrayMergeMode: mode, recurseIntoArrays: true });
+    }
+    else if (isArray(a[index]) && isArray(b[index])) {
+      return mergeArray(a[index] as any, b[index] as any, mode);
+    }
+
+    return b[index] ?? a[index];
+  }) as any;
+}

package/source/utils/middleware.ts

@@ -0,0 +1,69 @@
+export type ComposedMiddleware<Context = unknown> = (context: Context) => void;
+export type MiddlewareNext = () => void;
+export type Middleware<Context = unknown> = (context: Context, next: MiddlewareNext) => void;
+
+export type ComposedAsyncMiddleware<Context = unknown> = (context: Context) => Promise<void>;
+export type AsyncMiddlewareNext = () => void | Promise<void>;
+export type AsyncMiddleware<Context = unknown> = (context: Context, next: AsyncMiddlewareNext) => void | Promise<void>;
+
+export type MiddlewareOptions = {
+  allowMultipleNextCalls?: boolean,
+};
+
+export function composeMiddleware<Context = unknown>(middlewares: Middleware<Context>[], options: MiddlewareOptions = {}): ComposedMiddleware<Context> {
+  function composedMiddleware(context: Context): void {
+    let currentIndex = -1;
+
+    function dispatch(index: number): void {
+      if (index == middlewares.length) {
+        return;
+      }
+
+      const middleware = middlewares[index]!;
+      currentIndex = index;
+
+      function next(): void {
+        if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
+          throw new Error('next() called multiple times');
+        }
+
+        dispatch(index + 1);
+      }
+
+      middleware(context, next);
+    }
+
+    dispatch(0);
+  }
+
+  return composedMiddleware;
+}
+
+export function composeAsyncMiddleware<Context>(middlewares: AsyncMiddleware<Context>[], options: MiddlewareOptions = {}): ComposedAsyncMiddleware<Context> {
+  async function composedMiddleware(context: Context): Promise<void> {
+    let currentIndex = -1;
+
+    async function dispatch(index: number): Promise<void> {
+      if (index == middlewares.length) {
+        return;
+      }
+
+      const middleware = middlewares[index]!;
+      currentIndex = index;
+
+      async function next(): Promise<void> {
+        if ((index < currentIndex) && (options.allowMultipleNextCalls != true)) {
+          throw new Error('next() called multiple times');
+        }
+
+        await dispatch(index + 1);
+      }
+
+      await middleware(context, next);
+    }
+
+    await dispatch(0);
+  }
+
+  return composedMiddleware;
+}