@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/utils/proxy.js

@@ -1,18 +1,43 @@
-import { objectKeys } from './object/object.js';
-export const reflectMethodsMap = {
-    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
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-export const reflectMethods = objectKeys(reflectMethodsMap);
-export const propertyReflectMethods = new Set(['defineProperty', 'deleteProperty', 'get', 'getOwnPropertyDescriptor', 'has', 'set']);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var proxy_exports = {};
+__export(proxy_exports, {
+  propertyReflectMethods: () => propertyReflectMethods,
+  reflectMethods: () => reflectMethods,
+  reflectMethodsMap: () => reflectMethodsMap
+});
+module.exports = __toCommonJS(proxy_exports);
+var import_object = require("./object/object.js");
+const reflectMethodsMap = {
+  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
+};
+const reflectMethods = (0, import_object.objectKeys)(reflectMethodsMap);
+const propertyReflectMethods = /* @__PURE__ */ new Set(["defineProperty", "deleteProperty", "get", "getOwnPropertyDescriptor", "has", "set"]);

package/utils/random.js

@@ -1,46 +1,56 @@
-import { Alphabet } from './alphabet.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var random_exports = {};
+__export(random_exports, {
+  getRandomBytes: () => getRandomBytes,
+  getRandomString: () => getRandomString
+});
+module.exports = __toCommonJS(random_exports);
+var import_alphabet = require("./alphabet.js");
 const bufferSize = 20480;
-const bufferBypassThreshold = (bufferSize / 2) + 1;
+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, allowUnsafe = false) {
-    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;
+function getRandomBytes(count, allowUnsafe = false) {
+  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, alphabet = Alphabet.LowerUpperCaseNumbers) {
-    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];
-    }
+function getRandomString(length, alphabet = import_alphabet.Alphabet.LowerUpperCaseNumbers) {
+  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/utils/reflection.js

@@ -1,19 +1,47 @@
-import 'reflect-metadata'; // eslint-disable-line import/no-unassigned-import
-export function getDesignType(target, propertyKey) {
-    return Reflect.getMetadata('design:type', target, propertyKey);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reflection_exports = {};
+__export(reflection_exports, {
+  getDesignType: () => getDesignType,
+  getParameterTypes: () => getParameterTypes,
+  getReturnType: () => getReturnType,
+  hasDesignType: () => hasDesignType,
+  hasParameterTypes: () => hasParameterTypes,
+  hasReturnType: () => hasReturnType
+});
+module.exports = __toCommonJS(reflection_exports);
+var import_reflect_metadata = require("reflect-metadata");
+function getDesignType(target, propertyKey) {
+  return Reflect.getMetadata("design:type", target, propertyKey);
 }
-export function hasDesignType(target, propertyKey) {
-    return Reflect.hasMetadata('design:type', target, propertyKey);
+function hasDesignType(target, propertyKey) {
+  return Reflect.hasMetadata("design:type", target, propertyKey);
 }
-export function getParameterTypes(target, propertyKey) {
-    return Reflect.getMetadata('design:paramtypes', target, propertyKey);
+function getParameterTypes(target, propertyKey) {
+  return Reflect.getMetadata("design:paramtypes", target, propertyKey);
 }
-export function hasParameterTypes(target, propertyKey) {
-    return Reflect.hasMetadata('design:paramtypes', target, propertyKey);
+function hasParameterTypes(target, propertyKey) {
+  return Reflect.hasMetadata("design:paramtypes", target, propertyKey);
 }
-export function getReturnType(target, propertyKey) {
-    return Reflect.getMetadata('design:returntype', target, propertyKey);
+function getReturnType(target, propertyKey) {
+  return Reflect.getMetadata("design:returntype", target, propertyKey);
 }
-export function hasReturnType(target, propertyKey) {
-    return Reflect.hasMetadata('design:returntype', target, propertyKey);
+function hasReturnType(target, propertyKey) {
+  return Reflect.hasMetadata("design:returntype", target, propertyKey);
 }

package/utils/repl.js

@@ -1,16 +1,35 @@
-import { start as startRepl } from 'node:repl';
-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) {
-    const replServer = startRepl(options);
-    if (isDefined(options?.context)) {
-        for (const [key, value] of objectEntries(options.context)) {
-            replServer.context[key] = value;
-        }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repl_exports = {};
+__export(repl_exports, {
+  repl: () => repl
+});
+module.exports = __toCommonJS(repl_exports);
+var import_node_repl = require("node:repl");
+var import_object = require("./object/object.js");
+var import_type_guards = require("./type-guards.js");
+async function repl(options) {
+  const replServer = (0, import_node_repl.start)(options);
+  if ((0, import_type_guards.isDefined)(options?.context)) {
+    for (const [key, value] of (0, import_object.objectEntries)(options.context)) {
+      replServer.context[key] = value;
     }
-    await new Promise((resolve) => replServer.once('exit', resolve));
+  }
+  await new Promise((resolve) => replServer.once("exit", resolve));
 }

package/utils/set.js

@@ -1,44 +1,70 @@
-/* eslint-disable max-statements */
-import { compareByValueSelectionDescending } from './comparison.js';
-export function intersectSets(...sets) {
-    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)));
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var set_exports = {};
+__export(set_exports, {
+  differenceSets: () => differenceSets,
+  intersectSets: () => intersectSets,
+  symmetricDifferenceSets: () => symmetricDifferenceSets,
+  unionSets: () => unionSets,
+  uniquesSets: () => uniquesSets
+});
+module.exports = __toCommonJS(set_exports);
+var import_comparison = require("./comparison.js");
+function intersectSets(...sets) {
+  if (sets.length == 0) {
+    return [];
+  }
+  if (sets.length == 1) {
+    return [...sets[0]];
+  }
+  const sortedSets = sets.sort((0, import_comparison.compareByValueSelectionDescending)((set) => set.size));
+  const [smallestSet, ...otherSets] = sortedSets;
+  return [...smallestSet].filter((value) => !otherSets.some((set) => !set.has(value)));
 }
-export function differenceSets(base, ...sets) {
-    return [...base].filter((value) => !sets.some((set) => set.has(value)));
+function differenceSets(base, ...sets) {
+  return [...base].filter((value) => !sets.some((set) => set.has(value)));
 }
-export function symmetricDifferenceSets(...sets) {
-    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);
+function symmetricDifferenceSets(...sets) {
+  if (sets.length == 0) {
+    return /* @__PURE__ */ new Set();
+  }
+  if (sets.length == 1) {
+    return sets[0];
+  }
+  const [first, second, ...others] = sets;
+  return symmetricDifferenceSets(simpleSymmetricDifference(first, second), ...others);
 }
-export function uniquesSets(...sets) {
-    const result = new Set();
-    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);
-            }
-        }
+function uniquesSets(...sets) {
+  const result = /* @__PURE__ */ new Set();
+  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;
+  }
+  return result;
 }
-export function unionSets(...sets) {
-    return new Set(sets.flatMap((set) => [...set]));
+function unionSets(...sets) {
+  return new Set(sets.flatMap((set) => [...set]));
 }
 function simpleSymmetricDifference(a, b) {
-    return unionSets(differenceSets(a, b), differenceSets(b, a));
+  return unionSets(differenceSets(a, b), differenceSets(b, a));
 }

package/utils/singleton.js

@@ -1,22 +1,45 @@
-import { FactoryMap } from './factory-map.js';
-const globalScope = Symbol('global singleton scope');
-const scopes = new FactoryMap(() => new Map());
-export function singleton(scopeOrType, typeOrBuilder, _builder) {
-    const builder = _builder != undefined ? _builder : typeOrBuilder;
-    const scope = _builder != undefined ? scopeOrType : globalScope;
-    const type = _builder != undefined ? typeOrBuilder : scopeOrType;
-    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);
-        }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var singleton_exports = {};
+__export(singleton_exports, {
+  singleton: () => singleton
+});
+module.exports = __toCommonJS(singleton_exports);
+var import_factory_map = require("./factory-map.js");
+const globalScope = Symbol("global singleton scope");
+const scopes = new import_factory_map.FactoryMap(() => /* @__PURE__ */ new Map());
+function singleton(scopeOrType, typeOrBuilder, _builder) {
+  const builder = _builder != void 0 ? _builder : typeOrBuilder;
+  const scope = _builder != void 0 ? scopeOrType : globalScope;
+  const type = _builder != void 0 ? typeOrBuilder : scopeOrType;
+  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);
+  }
+  return instances.get(type);
 }
 async function asyncSingleton(instances, type, promise) {
-    const instance = await promise;
-    instances.set(type, instance);
-    return instance;
+  const instance = await promise;
+  instances.set(type, instance);
+  return instance;
 }

package/utils/sort.js

@@ -1,65 +1,89 @@
-import { compareByValue } from './comparison.js';
-export function quickSort(array, comparator, left, right) {
-    const copy = [...array];
-    quickSortInPlace(copy, comparator, left, right);
-    return copy;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sort_exports = {};
+__export(sort_exports, {
+  quickSort: () => quickSort,
+  quickSortAsync: () => quickSortAsync,
+  quickSortInPlace: () => quickSortInPlace,
+  quickSortInPlaceAsync: () => quickSortInPlaceAsync
+});
+module.exports = __toCommonJS(sort_exports);
+var import_comparison = require("./comparison.js");
+function quickSort(array, comparator, left, right) {
+  const copy = [...array];
+  quickSortInPlace(copy, comparator, left, right);
+  return copy;
 }
-export async function quickSortAsync(array, comparator, left, right) {
-    const copy = [...array];
-    await quickSortInPlaceAsync(copy, comparator, left, right);
-    return copy;
+async function quickSortAsync(array, comparator, left, right) {
+  const copy = [...array];
+  await quickSortInPlaceAsync(copy, comparator, left, right);
+  return copy;
 }
-export function quickSortInPlace(array, comparator = compareByValue, left = 0, right = (array.length - 1)) {
-    let pivot;
-    let partitionIndex;
-    if (left < right) {
-        pivot = right;
-        partitionIndex = partition(array, comparator, pivot, left, right);
-        quickSortInPlace(array, comparator, left, partitionIndex - 1);
-        quickSortInPlace(array, comparator, partitionIndex + 1, right);
-    }
+function quickSortInPlace(array, comparator = import_comparison.compareByValue, left = 0, right = array.length - 1) {
+  let pivot;
+  let partitionIndex;
+  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(array, comparator = compareByValue, left = 0, right = (array.length - 1)) {
-    let pivot;
-    let partitionIndex;
-    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);
-    }
+async function quickSortInPlaceAsync(array, comparator = import_comparison.compareByValue, left = 0, right = array.length - 1) {
+  let pivot;
+  let partitionIndex;
+  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(array, comparator, pivot, left, right) {
-    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++;
-        }
+  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;
+  }
+  swap(array, right, partitionIndex);
+  return partitionIndex;
 }
 async function partitionAsync(array, comparator, pivot, left, right) {
-    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++;
-        }
+  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;
+  }
+  swap(array, right, partitionIndex);
+  return partitionIndex;
 }
 function swap(array, i, j) {
-    const temp = array[i];
-    array[i] = array[j];
-    array[j] = temp;
+  const temp = array[i];
+  array[i] = array[j];
+  array[j] = temp;
 }