@tstdl/base 0.85.13 → 0.86.0-beta1

package/utils/proxy.js

@@ -1,43 +1,18 @@
-"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 });
+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
 };
-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"]);
+export const reflectMethods = objectKeys(reflectMethodsMap);
+export const propertyReflectMethods = new Set(['defineProperty', 'deleteProperty', 'get', 'getOwnPropertyDescriptor', 'has', 'set']);

package/utils/random.js

@@ -1,56 +1,46 @@
-"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");
+import { Alphabet } from './alphabet.js';
 const bufferSize = 20480;
-const bufferBypassThreshold = bufferSize / 2 + 1;
+const bufferBypassThreshold = (bufferSize / 2) + 1;
 let randomBytesBuffer = new Uint8Array();
 let randomBytesBufferIndex = 0;
-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 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 getRandomString(length, alphabet = import_alphabet.Alphabet.LowerUpperCaseNumbers) {
-  let result = "";
-  if (length < 1) {
+/**
+ * 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];
+    }
     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,47 +1,19 @@
-"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);
+import 'reflect-metadata'; // eslint-disable-line import/no-unassigned-import
+export function getDesignType(target, propertyKey) {
+    return Reflect.getMetadata('design:type', target, propertyKey);
 }
-function hasDesignType(target, propertyKey) {
-  return Reflect.hasMetadata("design:type", target, propertyKey);
+export function hasDesignType(target, propertyKey) {
+    return Reflect.hasMetadata('design:type', target, propertyKey);
 }
-function getParameterTypes(target, propertyKey) {
-  return Reflect.getMetadata("design:paramtypes", target, propertyKey);
+export function getParameterTypes(target, propertyKey) {
+    return Reflect.getMetadata('design:paramtypes', target, propertyKey);
 }
-function hasParameterTypes(target, propertyKey) {
-  return Reflect.hasMetadata("design:paramtypes", target, propertyKey);
+export function hasParameterTypes(target, propertyKey) {
+    return Reflect.hasMetadata('design:paramtypes', target, propertyKey);
 }
-function getReturnType(target, propertyKey) {
-  return Reflect.getMetadata("design:returntype", target, propertyKey);
+export function getReturnType(target, propertyKey) {
+    return Reflect.getMetadata('design:returntype', target, propertyKey);
 }
-function hasReturnType(target, propertyKey) {
-  return Reflect.hasMetadata("design:returntype", target, propertyKey);
+export function hasReturnType(target, propertyKey) {
+    return Reflect.hasMetadata('design:returntype', target, propertyKey);
 }

package/utils/repl.js

@@ -1,35 +1,16 @@
-"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;
+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;
+        }
     }
-  }
-  await new Promise((resolve) => replServer.once("exit", resolve));
+    await new Promise((resolve) => replServer.once('exit', resolve));
 }

package/utils/set.js

@@ -1,70 +1,44 @@
-"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)));
+/* 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)));
 }
-function differenceSets(base, ...sets) {
-  return [...base].filter((value) => !sets.some((set) => set.has(value)));
+export function differenceSets(base, ...sets) {
+    return [...base].filter((value) => !sets.some((set) => set.has(value)));
 }
-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 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 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);
-      }
+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);
+            }
+        }
     }
-  }
-  return result;
+    return result;
 }
-function unionSets(...sets) {
-  return new Set(sets.flatMap((set) => [...set]));
+export 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,45 +1,22 @@
-"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);
+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);
+        }
     }
-  }
-  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,89 +1,65 @@
-"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;
+import { compareByValue } from './comparison.js';
+export function quickSort(array, comparator, left, right) {
+    const copy = [...array];
+    quickSortInPlace(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 async function quickSortAsync(array, comparator, left, right) {
+    const copy = [...array];
+    await quickSortInPlaceAsync(copy, comparator, left, right);
+    return copy;
 }
-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 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);
+    }
 }
-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);
-  }
+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);
+    }
 }
 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;
 }