@tstdl/base 0.93.36 → 0.93.38

package/source/utils/patch-worker.ts

@@ -1,109 +0,0 @@
-import { Subject, debounceTime, defaultIfEmpty, firstValueFrom, merge, takeUntil, type Observable } from 'rxjs';
-
-import { CancellationToken } from '#/cancellation/token.js';
-import type { Record, StringMap } from '#/types/index.js';
-import { timeout } from './timing.js';
-import { isDefined, isObject, isUndefined } from './type-guards.js';
-
-const defaultDebounceTime = 5000;
-const defaultRetryDelay = 10000;
-
-export type PatchWorkerOptions<T extends StringMap> = {
-  debounceTime?: number,
-  retryDelay?: number,
-  handleOn?: Observable<any>,
-  completeOn?: Observable<any>,
-  handler(patch: Partial<T>): void | Promise<void>,
-  errorHandler?(error: Error): void | Promise<void>
-};
-
-export class PatchWorker<T extends Record> {
-  private readonly patchAddedSubject: Subject<void>;
-  private readonly handleSubject: Subject<void>;
-  private readonly completeToken: CancellationToken;
-  private readonly options: PatchWorkerOptions<T>;
-
-  private patch: Partial<T> | undefined;
-
-  constructor(options: PatchWorkerOptions<T>) {
-    this.options = options;
-
-    this.patchAddedSubject = new Subject();
-    this.handleSubject = new Subject();
-    this.completeToken = new CancellationToken();
-    this.patch = undefined;
-
-    if (isDefined(options.handleOn)) {
-      this.handleOn(options.handleOn);
-    }
-
-    if (isDefined(options.completeOn)) {
-      this.completeOn(options.completeOn);
-    }
-
-    void this.handleLoop();
-  }
-
-  handleOn(observable: Observable<any>): void {
-    observable.pipe(takeUntil(this.completeToken)).subscribe(() => this.handle());
-  }
-
-  completeOn(observable: Observable<any>): void {
-    observable.pipe(takeUntil(this.completeToken)).subscribe(() => this.complete());
-  }
-
-  add(patch: Partial<T>): void;
-  add<P extends keyof T>(key: P, value: T[P]): void;
-  add<P extends keyof T>(patchOrKey: Partial<T> | P, value?: T[P]): void {
-    if (this.completeToken.isSet) {
-      throw new Error('instance is completed');
-    }
-
-    if (isObject(patchOrKey)) {
-      this.patch = { ...this.patch, ...patchOrKey };
-    }
-    else {
-      this.patch = { ...this.patch, [patchOrKey]: value } as Partial<T>;
-    }
-
-    this.patchAddedSubject.next();
-  }
-
-  handle(): void {
-    this.handleSubject.next();
-  }
-
-  complete(): void {
-    this.patchAddedSubject.complete();
-    this.handleSubject.next();
-    this.handleSubject.complete();
-    this.completeToken.set();
-  }
-
-  private async handleLoop(): Promise<void> {
-    const debounce$ = this.patchAddedSubject.pipe(debounceTime(this.options.debounceTime ?? defaultDebounceTime));
-    const handle$ = merge(debounce$, this.handleSubject).pipe(takeUntil(this.completeToken), defaultIfEmpty(undefined));
-
-    let patch: Partial<T> | undefined;
-
-    while (this.completeToken.isUnset || isDefined(patch) || isDefined(this.patch)) {
-      await firstValueFrom(handle$);
-
-      if (isUndefined(patch) && isUndefined(this.patch)) {
-        continue;
-      }
-
-      patch = { ...patch, ...this.patch } as Partial<T>;
-      this.patch = undefined;
-
-      try {
-        await this.options.handler(patch);
-        patch = undefined;
-      }
-      catch (error: unknown) {
-        await this.options.errorHandler?.(error as Error);
-        await timeout(this.options.retryDelay ?? defaultRetryDelay);
-      }
-    }
-  }
-}

package/source/utils/patterns.ts

@@ -1,10 +0,0 @@
-/** Pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
-export const numberPattern = /^[+-]?(?:\d*\.?\d+|\d+\.?\d*|0[bB][01]+|0[xX][\da-fA-F]+|0[oO][0-7]+)$/u;
-
-/** Pattern matching valid email addresses */
-// eslint-disable-next-line no-control-regex, prefer-named-capture-group
-export const mailPattern = /^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/u;
-
-export function isEmail(value: string): boolean {
-  return mailPattern.test(value);
-}

package/source/utils/periodic-reporter.ts

@@ -1,81 +0,0 @@
-import { Subject, type Observable } from 'rxjs';
-
-import { CancellationToken } from '#/cancellation/token.js';
-import { DeferredPromise } from '#/promise/deferred-promise.js';
-import { cancelableTimeout } from './timing.js';
-
-export class PeriodicReporter {
-  private readonly reportSubject: Subject<number>;
-  private readonly interval: number;
-  private readonly ignoreZero: boolean;
-  private readonly resetAfterReport: boolean;
-  private readonly stopToken: CancellationToken;
-  private readonly stopped: DeferredPromise;
-
-  private running: boolean;
-  private counter: number;
-  private stopRequested: boolean;
-
-  get report(): Observable<number> {
-    return this.reportSubject.asObservable();
-  }
-
-  constructor(interval: number, ignoreZero: boolean, resetAfterReport: boolean) {
-    this.interval = interval;
-    this.ignoreZero = ignoreZero;
-    this.resetAfterReport = resetAfterReport;
-    this.running = false;
-
-    this.stopToken = new CancellationToken();
-    this.stopped = new DeferredPromise();
-    this.reportSubject = new Subject();
-  }
-
-  increase(count: number): void {
-    this.counter += count;
-  }
-
-  run(): void {
-    if (this.running) {
-      throw new Error('already started');
-    }
-
-    this.running = true;
-
-    void (async () => {
-      this.counter = 0;
-      this.stopRequested = false;
-      this.stopToken.unset();
-      this.stopped.reset();
-
-      while (!this.stopRequested) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-        await cancelableTimeout(this.interval, this.stopToken);
-
-        if (!this.stopRequested && (!this.ignoreZero || (this.counter > 0))) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-          this.emitReport(this.resetAfterReport);
-        }
-      }
-
-      this.running = false;
-      this.stopped.resolve();
-    })();
-  }
-
-  async stop(): Promise<void> {
-    if (!this.running) {
-      return;
-    }
-
-    this.stopRequested = true;
-    this.stopToken.set();
-    await this.stopped;
-  }
-
-  private emitReport(resetAfterReport: boolean): void {
-    this.reportSubject.next(this.counter);
-
-    if (resetAfterReport) {
-      this.counter = 0;
-    }
-  }
-}

package/source/utils/periodic-sampler.ts

@@ -1,100 +0,0 @@
-import { Subject, bufferCount, filter, map, type Observable } from 'rxjs';
-import { compareByValue } from './comparison.js';
-import { average } from './math.js';
-import { timeout } from './timing.js';
-
-export enum AggregationMode {
-  Minimum = 0,
-  Maximum = 1,
-  Mean = 2,
-  Median = 3,
-  FirstQuartile = 4,
-  ThirdQuartile = 5
-}
-
-export type SampleFunction = () => number | Promise<number>;
-
-export class PeriodicSampler {
-  private readonly sampleFunction: SampleFunction;
-  private readonly subject: Subject<number>;
-
-  private run: boolean;
-  private stopped: Promise<void>;
-
-  sampleInterval: number;
-
-  constructor(sampleFunction: SampleFunction, sampleInterval: number = 100) {
-    this.sampleFunction = sampleFunction;
-    this.sampleInterval = sampleInterval;
-
-    this.run = false;
-    this.subject = new Subject();
-  }
-
-  start(): void {
-    if (this.run) {
-      throw new Error('already started');
-    }
-
-    this.run = true;
-    this.stopped = this.runSampleLoop();
-  }
-
-  async stop(): Promise<void> {
-    this.run = false;
-    await this.stopped;
-  }
-
-  watch(threshold: number = 0, samples: number = 1, aggregation: AggregationMode = AggregationMode.Maximum): Observable<number> {
-    const observable = this.subject.pipe(
-      bufferCount(samples),
-      map((measures) => aggregate(aggregation, measures)),
-      filter((ms) => ms >= threshold)
-    );
-
-    return observable;
-  }
-
-  private async runSampleLoop(): Promise<void> {
-    while (this.run) {
-      const delay = await this.sampleFunction();
-      this.subject.next(delay);
-
-      await timeout(this.sampleInterval);
-    }
-  }
-}
-
-function aggregate(aggregation: AggregationMode, values: number[]): number {
-  switch (aggregation) {
-    case AggregationMode.Minimum:
-      return Math.min(...values);
-
-    case AggregationMode.Maximum:
-      return Math.max(...values);
-
-    case AggregationMode.Mean:
-      return average(values);
-
-    case AggregationMode.Median: {
-      values.sort(compareByValue);
-      const median = Math.floor(values.length / 2);
-      return values[median]!;
-    }
-
-    case AggregationMode.FirstQuartile: {
-      values.sort(compareByValue);
-      const firstQuartile = Math.floor(values.length / 4 * 1);
-      return values[firstQuartile]!;
-    }
-
-    case AggregationMode.ThirdQuartile: {
-      values.sort(compareByValue);
-      const thirdQuartile = Math.floor(values.length / 4 * 3);
-      return values[thirdQuartile]!;
-    }
-
-    default:
-      throw new Error(`aggregation mode ${aggregation as number} not implemented`);
-  }
-}

package/source/utils/provider-function-iterable.ts

@@ -1,40 +0,0 @@
-import { timeout } from './timing.js';
-
-export type ProviderFunction<T> = () => ProviderFunctionResult<T> | Promise<ProviderFunctionResult<T>>;
-
-export type ProviderFunctionResult<T> = { hasItem: boolean, item: T } | { hasItem: false, item?: null };
-
-export class ProviderFunctionIterable<T> implements AsyncIterable<T> {
-  private readonly providerFunction: ProviderFunction<T>;
-  private readonly delay: number;
-
-  private stopped: boolean;
-
-  constructor(providerFunction: ProviderFunction<T>, delay: number) {
-    this.providerFunction = providerFunction;
-    this.delay = delay;
-
-    this.stopped = false;
-  }
-
-  stop(): void {
-    this.stopped = true;
-  }
-
-  async *[Symbol.asyncIterator](): AsyncIterableIterator<T> {
-    while (!this.stopped) {
-      let result = this.providerFunction();
-
-      if (result instanceof Promise) {
-        result = await result;
-      }
-
-      if (result.hasItem) {
-        yield result.item;
-      }
-      else {
-        await timeout(this.delay);
-      }
-    }
-  }
-}

package/source/utils/proxy.ts

@@ -1,23 +0,0 @@
-import { objectKeys } from './object/object.js';
-
-export const reflectMethodsMap: Record<keyof ProxyHandler<object>, true> = {
-  apply: true,
-  construct: true,
-  defineProperty: true,
-  deleteProperty: true,
-  get: true,
-  getOwnPropertyDescriptor: true,
-  getPrototypeOf: true,
-  has: true,
-  isExtensible: true,
-  ownKeys: true,
-  preventExtensions: true,
-  set: true,
-  setPrototypeOf: true,
-};
-
-export type ReflectMethodsReturnTypeMap = { [P in keyof ProxyHandler<object>]-?: ReturnType<Required<ProxyHandler<object>>[P]> };
-
-export const reflectMethods = objectKeys(reflectMethodsMap);
-
-export const propertyReflectMethods = new Set<keyof ProxyHandler<object>>(['defineProperty', 'deleteProperty', 'get', 'getOwnPropertyDescriptor', 'has', 'set']);

package/source/utils/random.ts

@@ -1,57 +0,0 @@
-import { Alphabet } from './alphabet.js';
-
-const bufferSize = 20480;
-const bufferBypassThreshold = (bufferSize / 2) + 1;
-
-let randomBytesBuffer = new Uint8Array();
-let randomBytesBufferIndex = 0;
-
-/**
- * Generate cryptographically secure random bytes
- *
- * if allowUnsafe is true a view on the underlying pool is returned. This can be dangerous as the underlying
- * pool can be read and modified by other callers of {@link getRandomBytes} but improves performance as
- * less memory allocations and system calls are required
- * @param count number of bytes to get
- * @param allowUnsafe whether to allow sharing the underlying pool
- */
-export function getRandomBytes(count: number, allowUnsafe: boolean = false): Uint8Array<ArrayBuffer> {
-  if (!allowUnsafe || (count >= bufferBypassThreshold)) {
-    return globalThis.crypto.getRandomValues(new Uint8Array(count));
-  }
-
-  if (count > (randomBytesBuffer.byteLength - randomBytesBufferIndex)) {
-    randomBytesBuffer = globalThis.crypto.getRandomValues(new Uint8Array(bufferSize));
-    randomBytesBufferIndex = 0;
-  }
-
-  const end = randomBytesBufferIndex + count;
-  const bytes = randomBytesBuffer.subarray(randomBytesBufferIndex, end);
-  randomBytesBufferIndex = end;
-
-  return bytes;
-}
-
-/**
- * Generate a cryptographically secure random string (in terms of source of randomness).
- * @param length length of string
- * @param alphabet alphabet to choose characters from. Defaults to {@link Alphabet.LowerUpperCaseNumbers}
- */
-export function getRandomString(length: number, alphabet: string = Alphabet.LowerUpperCaseNumbers): string {
-  let result = '';
-
-  if (length < 1) {
-    return result;
-  }
-
-  const bytes = getRandomBytes(length * Uint16Array.BYTES_PER_ELEMENT, true);
-  const values = new Uint16Array(bytes.buffer, bytes.byteOffset, length);
-  const factor = alphabet.length / (2 ** (Uint16Array.BYTES_PER_ELEMENT * 8));
-
-  for (let i = 0; i < length; i++) {
-    const index = Math.floor(values[i]! * factor);
-    result += alphabet[index]!;
-  }
-
-  return result;
-}

package/source/utils/reactive-value-to-signal.ts

@@ -1,23 +0,0 @@
-import { isObservable } from 'rxjs';
-
-import { computed, isSignal, toSignal, type Signal, type ToSignalOptions } from '#/signals/api.js';
-import type { ReactiveValue } from '#/types/index.js';
-
-export type ReactiveValueToSignalOptions<T> = ToSignalOptions<T>;
-
-export function reactiveValueToSignal<T>(source: ReactiveValue<T>): Signal<T | undefined>;
-export function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | undefined> & { initialValue?: undefined, requireSync?: false }): Signal<T | undefined>; // eslint-disable-line @typescript-eslint/unified-signatures
-export function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | null> & { initialValue?: null, requireSync?: false }): Signal<T | null>;
-export function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T> & { initialValue?: undefined, requireSync: true }): Signal<T>;
-export function reactiveValueToSignal<T, const I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | I> & { initialValue: I, requireSync?: false }): Signal<T | I>;
-export function reactiveValueToSignal<T, I = undefined>(source: ReactiveValue<T>, options?: ReactiveValueToSignalOptions<T | I> & { initialValue?: I }): Signal<T | I> {
-  if (isSignal(source)) {
-    return source;
-  }
-
-  if (isObservable(source)) {
-    return toSignal(source, options as any) as Signal<T | I>; // eslint-disable-line @typescript-eslint/no-unsafe-argument
-  }
-
-  return computed(() => source);
-}

package/source/utils/reflection.ts

@@ -1,27 +0,0 @@
-import 'reflect-metadata/lite';
-
-import type { Type } from '#/types/index.js';
-
-export function getDesignType(target: object, propertyKey?: string | symbol): Type {
-  return Reflect.getMetadata('design:type', target, propertyKey as string) as Type;
-}
-
-export function hasDesignType(target: object, propertyKey?: string | symbol): boolean {
-  return Reflect.hasMetadata('design:type', target, propertyKey as string);
-}
-
-export function getParameterTypes(target: object, propertyKey?: string | symbol): Type[] | undefined {
-  return Reflect.getMetadata('design:paramtypes', target, propertyKey as string) as (Type[] | undefined);
-}
-
-export function hasParameterTypes(target: object, propertyKey?: string | symbol): boolean {
-  return Reflect.hasMetadata('design:paramtypes', target, propertyKey as string);
-}
-
-export function getReturnType(target: object, propertyKey?: string | symbol): Type {
-  return Reflect.getMetadata('design:returntype', target, propertyKey as string) as Type;
-}
-
-export function hasReturnType(target: object, propertyKey?: string | symbol): boolean {
-  return Reflect.hasMetadata('design:returntype', target, propertyKey as string);
-}

package/source/utils/repl.ts

@@ -1,23 +0,0 @@
-import type { ReplOptions } from 'node:repl';
-
-import { dynamicImport } from '#/import.js';
-import type { Record } from '#/types/index.js';
-import { objectEntries } from './object/object.js';
-import { isDefined } from './type-guards.js';
-
-/**
- * Starts an interactive (repl) session (node only)
- * @param context context to set the repl context to
- */
-export async function repl(options?: ReplOptions & { context?: Record<string, unknown> }): Promise<void> {
-  const { start: startRepl } = await dynamicImport<typeof import('node:repl')>('node:repl');
-  const replServer = startRepl(options);
-
-  if (isDefined(options?.context)) {
-    for (const [key, value] of objectEntries(options.context)) {
-      replServer.context[key] = value;
-    }
-  }
-
-  await new Promise((resolve) => replServer.once('exit', resolve));
-}

package/source/utils/set.ts

@@ -1,58 +0,0 @@
-import { compareByValueSelectionDescending } from './comparison.js';
-
-export function intersectSets<T>(...sets: Set<T>[]): T[] {
-  if (sets.length == 0) {
-    return [];
-  }
-
-  if (sets.length == 1) {
-    return [...sets[0]!];
-  }
-
-  const sortedSets = sets.sort(compareByValueSelectionDescending((set) => set.size));
-  const [smallestSet, ...otherSets] = sortedSets;
-
-  return [...smallestSet!].filter((value) => !otherSets.some((set) => !set.has(value)));
-}
-
-export function differenceSets<T>(base: Set<T>, ...sets: Set<T>[]): T[] {
-  return [...base].filter((value) => !sets.some((set) => set.has(value)));
-}
-
-export function symmetricDifferenceSets<T>(...sets: Set<T>[]): Set<T> {
-  if (sets.length == 0) {
-    return new Set();
-  }
-
-  if (sets.length == 1) {
-    return sets[0]!;
-  }
-
-  const [first, second, ...others] = sets;
-
-  return symmetricDifferenceSets(simpleSymmetricDifference(first!, second!), ...others);
-}
-
-export function uniquesSets<T>(...sets: Set<T>[]): Set<T> {
-  const result = new Set<T>();
-
-  for (const set of sets) {
-    for (const value of set) {
-      const unique = sets.every((otherSet) => (set == otherSet) || !otherSet.has(value));
-
-      if (unique) {
-        result.add(value);
-      }
-    }
-  }
-
-  return result;
-}
-
-export function unionSets<T>(...sets: Iterable<T>[]): Set<T> {
-  return new Set(sets.flatMap((set) => [...set]));
-}
-
-function simpleSymmetricDifference<T>(a: Set<T>, b: Set<T>): Set<T> {
-  return unionSets(differenceSets(a, b), differenceSets(b, a));
-}

package/source/utils/singleton.ts

@@ -1,38 +0,0 @@
-import type { ObjectLiteral } from '#/types/index.js';
-import { FactoryMap } from './factory-map.js';
-
-export type Builder<T> = () => T;
-export type AsyncBuilder<T> = () => Promise<T>;
-
-const globalScope = Symbol('global singleton scope');
-const scopes = new FactoryMap(() => new Map<any, any>());
-
-export function singleton<T>(type: ObjectLiteral, builder: Builder<T>): T;
-export function singleton<T>(type: ObjectLiteral, builder: AsyncBuilder<T>): Promise<T>;
-export function singleton<T>(scope: ObjectLiteral, type: ObjectLiteral, builder: Builder<T>): T;
-export function singleton<T>(scope: ObjectLiteral, type: ObjectLiteral, builder: AsyncBuilder<T>): Promise<T>;
-export function singleton<T>(scopeOrType: ObjectLiteral, typeOrBuilder: Builder<T> | AsyncBuilder<T> | ObjectLiteral, _builder?: Builder<T>): T | Promise<T> {
-  const builder = _builder ?? typeOrBuilder as Builder<T> | AsyncBuilder<T>;
-  const scope = _builder == undefined ? globalScope : scopeOrType;
-  const type = _builder == undefined ? scopeOrType : typeOrBuilder;
-
-  const instances = scopes.get(scope);
-
-  if (!instances.has(type)) {
-    const instanceOrPromise = builder();
-    instances.set(type, instanceOrPromise);
-
-    if (instanceOrPromise instanceof Promise) {
-      return asyncSingleton(instances, type, instanceOrPromise);
-    }
-  }
-
-  return instances.get(type) as T | Promise<T>;
-}
-
-async function asyncSingleton<T>(instances: Map<any, any>, type: any, promise: Promise<T>): Promise<T> {
-  const instance = await promise;
-  instances.set(type, instance);
-
-  return instance;
-}

package/source/utils/sort.ts

@@ -1,90 +0,0 @@
-import { compareByValue } from './comparison.js';
-
-export type Comparator<T> = (a: T, b: T) => number;
-export type AsyncComparator<T> = (a: T, b: T) => number | Promise<number>;
-
-export function quickSort<T>(array: T[], comparator?: Comparator<T>, left?: number, right?: number): T[] {
-  const copy = [...array];
-  quickSortInPlace(copy, comparator, left, right);
-
-  return copy;
-}
-
-export async function quickSortAsync<T>(array: T[], comparator?: AsyncComparator<T>, left?: number, right?: number): Promise<T[]> {
-  const copy = [...array];
-  await quickSortInPlaceAsync(copy, comparator, left, right);
-
-  return copy;
-}
-
-export function quickSortInPlace<T>(array: T[], comparator: Comparator<T> = compareByValue, left: number = 0, right: number = (array.length - 1)): void {
-  let pivot: number;
-  let partitionIndex: number;
-
-  if (left < right) {
-    pivot = right;
-    partitionIndex = partition(array, comparator, pivot, left, right);
-
-    quickSortInPlace(array, comparator, left, partitionIndex - 1);
-    quickSortInPlace(array, comparator, partitionIndex + 1, right);
-  }
-}
-
-export async function quickSortInPlaceAsync<T>(array: T[], comparator: AsyncComparator<T> = compareByValue, left: number = 0, right: number = (array.length - 1)): Promise<void> {
-  let pivot: number;
-  let partitionIndex: number;
-
-  if (left < right) {
-    pivot = right;
-    partitionIndex = await partitionAsync(array, comparator, pivot, left, right);
-
-    await quickSortInPlaceAsync(array, comparator, left, partitionIndex - 1);
-    await quickSortInPlaceAsync(array, comparator, partitionIndex + 1, right);
-  }
-}
-
-function partition<T>(array: T[], comparator: Comparator<T>, pivot: number, left: number, right: number): number {
-  const pivotValue = array[pivot]!;
-  let partitionIndex = left;
-
-  for (let i = left; i < right; i++) {
-    const comparison = comparator(array[i]!, pivotValue);
-
-    if (comparison < 0) {
-      swap(array, i, partitionIndex);
-      partitionIndex++;
-    }
-  }
-
-  swap(array, right, partitionIndex);
-
-  return partitionIndex;
-}
-
-async function partitionAsync<T>(array: T[], comparator: AsyncComparator<T>, pivot: number, left: number, right: number): Promise<number> {
-  const pivotValue = array[pivot]!;
-  let partitionIndex = left;
-
-  for (let i = left; i < right; i++) {
-    const comparisonReturnValue = comparator(array[i]!, pivotValue);
-
-    const comparison = (typeof comparisonReturnValue == 'number')
-      ? comparisonReturnValue
-      : await comparisonReturnValue;
-
-    if (comparison < 0) {
-      swap(array, i, partitionIndex);
-      partitionIndex++;
-    }
-  }
-
-  swap(array, right, partitionIndex);
-
-  return partitionIndex;
-}
-
-function swap(array: any[], i: number, j: number): void {
-  const temp = array[i];
-  array[i] = array[j];
-  array[j] = temp;
-}