umt 2.1.1 → 2.2.0

package/module/es5/Array/drop.d.ts

@@ -1,9 +1,9 @@
 /**
- * 配列の先頭からn個の要素を除外した新しい配列を返します。
- * @param {T[]} array 対象の配列
- * @param {number} n 除外する要素の数
- * @param {"left" | "right" | "between"} direction 除外する方向
- * @returns n個の要素を除外した新しい配列
+ * Returns a new array with n elements removed from the specified direction
+ * @param {T[]} array The target array
+ * @param {number} n The number of elements to remove
+ * @param {"left" | "right" | "between"} direction The direction to remove elements from
+ * @returns A new array with n elements removed
  *
  * @example drop([1, 2, 3, 4, 5], 2); // [3, 4, 5]
  * @example drop([1, 2, 3, 4, 5], 2, "left"); // [3, 4, 5]

package/module/es5/Array/drop.js

@@ -11,11 +11,11 @@ function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Sym
 function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /**
- * 配列の先頭からn個の要素を除外した新しい配列を返します。
- * @param {T[]} array 対象の配列
- * @param {number} n 除外する要素の数
- * @param {"left" | "right" | "between"} direction 除外する方向
- * @returns n個の要素を除外した新しい配列
+ * Returns a new array with n elements removed from the specified direction
+ * @param {T[]} array The target array
+ * @param {number} n The number of elements to remove
+ * @param {"left" | "right" | "between"} direction The direction to remove elements from
+ * @returns A new array with n elements removed
  *
  * @example drop([1, 2, 3, 4, 5], 2); // [3, 4, 5]
  * @example drop([1, 2, 3, 4, 5], 2, "left"); // [3, 4, 5]

package/module/es5/Array/dualPivotQuickSort.d.ts

@@ -0,0 +1,16 @@
+type CompareFunction<T> = (a: T, b: T) => number;
+/**
+ * Sort array using dual-pivot quicksort algorithm
+ * More efficient than traditional quicksort for arrays with many duplicate values
+ * @param array - Array to be sorted
+ * @param compareFunction - Optional comparison function
+ * @param startIndex - Optional starting index (default: 0)
+ * @param endIndex - Optional ending index (default: array.length - 1)
+ * @param insertionSortThreshold - Optional threshold for insertion sort (default: 10)
+ * @returns Sorted array
+ * @example
+ * dualPivotQuickSort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]); // [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
+ * dualPivotQuickSort(['banana', 'apple', 'orange']); // ['apple', 'banana', 'orange']
+ */
+export declare const dualPivotQuickSort: <T>(array: T[], compareFunction?: CompareFunction<T>, startIndex?: number, endIndex?: number, insertionSortThreshold?: number) => T[];
+export {};

package/module/es5/Array/dualPivotQuickSort.js

@@ -0,0 +1,201 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dualPivotQuickSort = void 0;
+var _compareFunctionDefault = require("./compareFunctionDefault");
+/**
+ * Get the median of three elements in the array
+ * @param array - The input array
+ * @param a - Index of the first element
+ * @param b - Index of the second element
+ * @param c - Index of the third element
+ * @param compareFunction - Comparison function
+ * @returns Index of the median element
+ */
+var medianOfThree = function medianOfThree(array, a, b, c, compareFunction) {
+  // Return the index of the median value
+  var values = [{
+    index: a,
+    value: array[a]
+  }, {
+    index: b,
+    value: array[b]
+  }, {
+    index: c,
+    value: array[c]
+  }];
+
+  // Sort and return the middle element's index
+  values.sort(function (x, y) {
+    return compareFunction(x.value, y.value);
+  });
+  return values[1].index;
+};
+
+/**
+ * Select dual pivots and partition the array into three parts
+ * @param array - Array to be partitioned
+ * @param low - Starting index
+ * @param high - Ending index
+ * @param compareFunction - Comparison function
+ * @returns Object containing left and right pivot indices
+ */
+var partition = function partition(array, low, high, compareFunction) {
+  // Select pivot candidates
+  var length = high - low;
+  var gap = Math.max(1, Math.floor(length / 3));
+
+  // Find optimal pivot positions
+  var leftPivotIndex = medianOfThree(array, low, low + gap, Math.min(low + 2 * gap, high), compareFunction);
+  var rightPivotIndex = medianOfThree(array, Math.max(low, high - 2 * gap), high - gap, high, compareFunction);
+
+  // Move pivots to ends
+  if (leftPivotIndex !== low) {
+    var _ref = [array[leftPivotIndex], array[low]];
+    array[low] = _ref[0];
+    array[leftPivotIndex] = _ref[1];
+  }
+  if (rightPivotIndex !== high) {
+    var _ref2 = [array[rightPivotIndex], array[high]];
+    array[high] = _ref2[0];
+    array[rightPivotIndex] = _ref2[1];
+  }
+
+  // Swap pivots if needed
+  if (compareFunction(array[low], array[high]) > 0) {
+    var _ref3 = [array[high], array[low]];
+    array[low] = _ref3[0];
+    array[high] = _ref3[1];
+  }
+
+  // Initialize partition boundaries
+  var left = low + 1;
+  var right = high - 1;
+  var current = left;
+
+  // Partition into three parts
+  while (current <= right) {
+    // Handle elements smaller than left pivot
+    if (compareFunction(array[current], array[low]) < 0) {
+      var _ref4 = [array[left], array[current]];
+      array[current] = _ref4[0];
+      array[left] = _ref4[1];
+      left++;
+    }
+    // Handle elements larger than right pivot
+    else if (compareFunction(array[current], array[high]) > 0) {
+      // Find suitable position from right
+      while (current < right && compareFunction(array[right], array[high]) > 0) {
+        right--;
+      }
+      var _ref5 = [array[right], array[current]];
+      array[current] = _ref5[0];
+      array[right] = _ref5[1];
+      right--;
+      // Check if swapped element is smaller than left pivot
+      if (compareFunction(array[current], array[low]) < 0) {
+        var _ref6 = [array[left], array[current]];
+        array[current] = _ref6[0];
+        array[left] = _ref6[1];
+        left++;
+      }
+    }
+    current++;
+  }
+
+  // Move pivots to their final positions
+  left--;
+  right++;
+  var _ref7 = [array[left], array[low]];
+  array[low] = _ref7[0];
+  array[left] = _ref7[1];
+  var _ref8 = [array[right], array[high]];
+  array[high] = _ref8[0];
+  array[right] = _ref8[1];
+  return {
+    leftPivotIndex: left,
+    rightPivotIndex: right
+  };
+};
+
+/**
+ * Sort small arrays using selection sort
+ * @param array - Array to be sorted
+ * @param start - Starting index
+ * @param end - Ending index
+ * @param compareFunction - Comparison function
+ */
+var insertionSort = function insertionSort(array, start, end, compareFunction) {
+  for (var index = start + 1; index <= end; index++) {
+    var current = array[index];
+    var index_ = index - 1;
+    while (index_ >= start && compareFunction(array[index_], current) > 0) {
+      array[index_ + 1] = array[index_];
+      index_--;
+    }
+    array[index_ + 1] = current;
+  }
+};
+
+/**
+ * Internal implementation of dual-pivot quicksort
+ * @param array - Array to be sorted
+ * @param start - Starting index
+ * @param end - Ending index
+ * @param compareFunction - Comparison function
+ * @param insertionSortThreshold - Threshold for switching to insertion sort
+ */
+var _sortRange = function sortRange(array, start, end, compareFunction, insertionSortThreshold) {
+  // Use insertion sort for small arrays
+  if (end - start + 1 <= insertionSortThreshold) {
+    insertionSort(array, start, end, compareFunction);
+    return;
+  }
+
+  // Get partition indices
+  var _partition = partition(array, start, end, compareFunction),
+    leftPivotIndex = _partition.leftPivotIndex,
+    rightPivotIndex = _partition.rightPivotIndex;
+
+  // Sort left partition
+  _sortRange(array, start, leftPivotIndex - 1, compareFunction, insertionSortThreshold);
+
+  // Sort middle partition
+  if (rightPivotIndex - leftPivotIndex > 1) {
+    _sortRange(array, leftPivotIndex + 1, rightPivotIndex - 1, compareFunction, insertionSortThreshold);
+  }
+
+  // Sort right partition
+  _sortRange(array, rightPivotIndex + 1, end, compareFunction, insertionSortThreshold);
+};
+
+/**
+ * Sort array using dual-pivot quicksort algorithm
+ * More efficient than traditional quicksort for arrays with many duplicate values
+ * @param array - Array to be sorted
+ * @param compareFunction - Optional comparison function
+ * @param startIndex - Optional starting index (default: 0)
+ * @param endIndex - Optional ending index (default: array.length - 1)
+ * @param insertionSortThreshold - Optional threshold for insertion sort (default: 10)
+ * @returns Sorted array
+ * @example
+ * dualPivotQuickSort([3, 1, 4, 1, 5, 9, 2, 6, 5, 3]); // [1, 1, 2, 3, 3, 4, 5, 5, 6, 9]
+ * dualPivotQuickSort(['banana', 'apple', 'orange']); // ['apple', 'banana', 'orange']
+ */
+var dualPivotQuickSort = exports.dualPivotQuickSort = function dualPivotQuickSort(array) {
+  var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
+  var startIndex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var endIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
+  var insertionSortThreshold = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 10;
+  // Validate and adjust indices
+  var validStartIndex = Math.max(0, Math.min(startIndex, array.length - 1));
+  var validEndIndex = Math.max(validStartIndex, Math.min(endIndex, array.length - 1));
+
+  // Sort array if valid range exists
+  if (validEndIndex >= validStartIndex) {
+    _sortRange(array, validStartIndex, validEndIndex, compareFunction, insertionSortThreshold);
+  }
+  return array;
+};

package/module/es5/Array/first.d.ts

@@ -1,8 +1,8 @@
 import type { First } from "$/logic/first";
 /**
- * 配列の先頭の要素を返す
- * @param array 配列
- * @returns 配列の先頭の要素
+ * Returns the first element of an array
+ * @param array The input array
+ * @returns The first element of the array, or undefined if the array is empty
  * @example first([1, 2, 3]); // 1
  */
 export declare const first: <T extends unknown[]>(array: T) => First<T> extends never ? T[number] | undefined : First<T>;

package/module/es5/Array/first.js

@@ -5,9 +5,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.first = void 0;
 /**
- * 配列の先頭の要素を返す
- * @param array 配列
- * @returns 配列の先頭の要素
+ * Returns the first element of an array
+ * @param array The input array
+ * @returns The first element of the array, or undefined if the array is empty
  * @example first([1, 2, 3]); // 1
  */
 var first = exports.first = function first(array) {

package/module/es5/Array/generateNumberArray.d.ts

@@ -1,10 +1,10 @@
 /**
- * 指定された要素数まで数値型の配列を生成する
- * @param length 配列の長さ
- * @param min 最小値 (デフォルト: 0)
- * @param max 最大値 (デフォルト: length - 1)
- * @param random ランダムな値を生成するかどうか (デフォルト: false)
- * @returns 数値型の配列
+ * Generates an array of numbers with the specified length
+ * @param length The length of the array
+ * @param min The minimum value (default: 0)
+ * @param max The maximum value (default: length - 1)
+ * @param random Whether to generate random values (default: false)
+ * @returns Array of numbers
  * @example generateNumberArray(5); // [0, 1, 2, 3, 4]
  * @example generateNumberArray(5, 10, 14); // [10, 11, 12, 13, 14]
  */

package/module/es5/Array/generateNumberArray.js

@@ -5,12 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.generateNumberArray = void 0;
 /**
- * 指定された要素数まで数値型の配列を生成する
- * @param length 配列の長さ
- * @param min 最小値 (デフォルト: 0)
- * @param max 最大値 (デフォルト: length - 1)
- * @param random ランダムな値を生成するかどうか (デフォルト: false)
- * @returns 数値型の配列
+ * Generates an array of numbers with the specified length
+ * @param length The length of the array
+ * @param min The minimum value (default: 0)
+ * @param max The maximum value (default: length - 1)
+ * @param random Whether to generate random values (default: false)
+ * @returns Array of numbers
  * @example generateNumberArray(5); // [0, 1, 2, 3, 4]
  * @example generateNumberArray(5, 10, 14); // [10, 11, 12, 13, 14]
  */

package/module/es5/Array/getArraysCommon.d.ts

@@ -1,8 +1,8 @@
 /**
- * 共通の要素を取り出す
- * @param {T[]} array 最初の配列
- * @param {T[][]} arrays 他の配列群
- * @returns {O} 共通の要素を含む配列
+ * Extract common elements from multiple arrays
+ * @param {T[]} array The first array
+ * @param {T[][]} arrays Additional arrays to compare
+ * @returns {O} Array containing common elements
  * @example getArraysCommon([1, 2, 3], [2, 3, 4], [2, 5, 3]); // [2, 3]
  */
 export declare const getArraysCommon: <O, T extends unknown[] = unknown[]>(array: T, ...arrays: T[]) => O;

package/module/es5/Array/getArraysCommon.js

@@ -5,10 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getArraysCommon = void 0;
 /**
- * 共通の要素を取り出す
- * @param {T[]} array 最初の配列
- * @param {T[][]} arrays 他の配列群
- * @returns {O} 共通の要素を含む配列
+ * Extract common elements from multiple arrays
+ * @param {T[]} array The first array
+ * @param {T[][]} arrays Additional arrays to compare
+ * @returns {O} Array containing common elements
  * @example getArraysCommon([1, 2, 3], [2, 3, 4], [2, 5, 3]); // [2, 3]
  */
 var getArraysCommon = exports.getArraysCommon = function getArraysCommon(array) {

package/module/es5/Array/getArraysDiff.d.ts

@@ -1,8 +1,8 @@
 /**
- * 共通しない要素をとりだす
- * @param  {T[]} array
- * @param  {T[]} arrays
- * @returns unknown[]
+ * Extract elements that are not common between arrays
+ * @param  {T[]} array The first array
+ * @param  {T[]} arrays Additional arrays to compare
+ * @returns {unknown[]} Array containing elements that appear only once across all arrays
  * @example getArraysDiff([1, 2, 3], [2, 3, 4]); // [1, 4]
  */
 export declare const getArraysDiff: <O, T extends unknown[] = unknown[]>(array: T, ...arrays: T[]) => O;

package/module/es5/Array/getArraysDiff.js

@@ -12,10 +12,10 @@ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol
 function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
 function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 /**
- * 共通しない要素をとりだす
- * @param  {T[]} array
- * @param  {T[]} arrays
- * @returns unknown[]
+ * Extract elements that are not common between arrays
+ * @param  {T[]} array The first array
+ * @param  {T[]} arrays Additional arrays to compare
+ * @returns {unknown[]} Array containing elements that appear only once across all arrays
  * @example getArraysDiff([1, 2, 3], [2, 3, 4]); // [1, 4]
  */
 var getArraysDiff = exports.getArraysDiff = function getArraysDiff(array) {

package/module/es5/Array/groupBy.d.ts

@@ -1,7 +1,11 @@
 /**
- * 配列の要素をグループ化する
- * @param array グループ化する配列
- * @param iteratee 各要素に適用するグループ化関数
- * @returns グループ化されたオブジェクト
+ * Groups elements of an array based on a given iteratee function
+ * @param array Array to group
+ * @param iteratee Function to determine the group key for each element
+ * @returns Object with grouped elements
+ * @example
+ * groupBy([6.1, 4.2, 6.3], Math.floor); // { '4': [4.2], '6': [6.1, 6.3] }
+ * groupBy(["one", "two", "three"], (str) => str.length); // { '3': ['one', 'two'], '5': ['three'] }
+ * groupBy(["apple", "banana", "carrot"], (str) => str[0]); // { 'a': ['apple'], 'b': ['banana'], 'c': ['carrot'] }
  */
 export declare const groupBy: <T, K extends string | number>(array: T[], iteratee: (value: T, index: number, array: T[]) => K) => Record<K, T[]>;

package/module/es5/Array/groupBy.js

@@ -5,10 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.groupBy = void 0;
 /**
- * 配列の要素をグループ化する
- * @param array グループ化する配列
- * @param iteratee 各要素に適用するグループ化関数
- * @returns グループ化されたオブジェクト
+ * Groups elements of an array based on a given iteratee function
+ * @param array Array to group
+ * @param iteratee Function to determine the group key for each element
+ * @returns Object with grouped elements
+ * @example
+ * groupBy([6.1, 4.2, 6.3], Math.floor); // { '4': [4.2], '6': [6.1, 6.3] }
+ * groupBy(["one", "two", "three"], (str) => str.length); // { '3': ['one', 'two'], '5': ['three'] }
+ * groupBy(["apple", "banana", "carrot"], (str) => str[0]); // { 'a': ['apple'], 'b': ['banana'], 'c': ['carrot'] }
  */
 var groupBy = exports.groupBy = function groupBy(array, iteratee) {
   return array.reduce(function (accumulator, value, index, array) {

package/module/es5/Array/index.d.ts

@@ -4,6 +4,7 @@ export * from "./checkFlagAlignment";
 export * from "./chunk";
 export * from "./compact";
 export * from "./drop";
+export * from "./dualPivotQuickSort";
 export * from "./first";
 export * from "./generateNumberArray";
 export * from "./getArraysCommon";

package/module/es5/Array/index.js

@@ -69,6 +69,17 @@ Object.keys(_drop).forEach(function (key) {
     }
   });
 });
+var _dualPivotQuickSort = require("./dualPivotQuickSort");
+Object.keys(_dualPivotQuickSort).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _dualPivotQuickSort[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _dualPivotQuickSort[key];
+    }
+  });
+});
 var _first = require("./first");
 Object.keys(_first).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/module/es5/Array/insertionSort.d.ts

@@ -1,11 +1,12 @@
+import type { CompareFunction } from "$/array/compareFunction";
 /**
- * 挿入ソートを使用して配列をソート
+ * Sort an array using insertion sort algorithm
  *
- * @param array ソートする配列
- * @param compareFunction 比較関数
- * @param start ソートを開始する配列のインデックス
- * @param end ソートを終了する配列のインデックス
- * @returns ソートされた配列
+ * @param array Array to sort
+ * @param compareFunction Function to compare two elements
+ * @param start Starting index for sorting (inclusive)
+ * @param end Ending index for sorting (inclusive)
+ * @returns Sorted array
  *
  * @example
  * const numbers = [4, 2, 7, 1, 3];
@@ -19,4 +20,4 @@
  * const numbers = [4, 2, 7, 1, 3];
  * insertionSort(numbers, undefined, 1, 3); // [4, 1, 2, 7, 3]
  */
-export declare const insertionSort: <T>(array: T[], compareFunction?: (a: T, b: T) => number, start?: number, end?: number) => T[];
+export declare const insertionSort: <T>(array: T[], compareFunction?: CompareFunction<T>, start?: number, end?: number) => T[];

package/module/es5/Array/insertionSort.js

@@ -6,13 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.insertionSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
 /**
- * 挿入ソートを使用して配列をソート
+ * Sort an array using insertion sort algorithm
  *
- * @param array ソートする配列
- * @param compareFunction 比較関数
- * @param start ソートを開始する配列のインデックス
- * @param end ソートを終了する配列のインデックス
- * @returns ソートされた配列
+ * @param array Array to sort
+ * @param compareFunction Function to compare two elements
+ * @param start Starting index for sorting (inclusive)
+ * @param end Ending index for sorting (inclusive)
+ * @returns Sorted array
  *
  * @example
  * const numbers = [4, 2, 7, 1, 3];

package/module/es5/Array/mergeSort.d.ts

@@ -1,8 +1,9 @@
+import type { CompareFunction } from "$/array/compareFunction";
 /**
- * マージソート
- * @param  {T[]} array 配列
- * @param  {(a: T, b: T) => number} compareFunction 比較関数
- * @returns T[]
+ * Merge sort implementation
+ * @param  {T[]} array Array to sort
+ * @param  {(a: T, b: T) => number} compareFunction Comparison function
+ * @returns {T[]} Sorted array
  * @example mergeSort([1, 3, 2, 4, 5], (a, b) => a - b); // [1, 2, 3, 4, 5]
  */
-export declare const mergeSort: <T>(array: T[], compareFunction?: (a: T, b: T) => number) => T[];
+export declare const mergeSort: <T>(array: T[], compareFunction?: CompareFunction<T>) => T[];

package/module/es5/Array/mergeSort.js

@@ -6,10 +6,10 @@ Object.defineProperty(exports, "__esModule", {
 exports.mergeSort = void 0;
 var _compareFunctionDefault = require("./compareFunctionDefault");
 /**
- * マージソート
- * @param  {T[]} array 配列
- * @param  {(a: T, b: T) => number} compareFunction 比較関数
- * @returns T[]
+ * Merge sort implementation
+ * @param  {T[]} array Array to sort
+ * @param  {(a: T, b: T) => number} compareFunction Comparison function
+ * @returns {T[]} Sorted array
  * @example mergeSort([1, 3, 2, 4, 5], (a, b) => a - b); // [1, 2, 3, 4, 5]
  */
 var _mergeSort = exports.mergeSort = function mergeSort(array) {
@@ -24,11 +24,11 @@ var _mergeSort = exports.mergeSort = function mergeSort(array) {
 };
 
 /**
- * 2つの配列をマージする関数
- * @param left - マージする左の配列
- * @param right - マージする右の配列
- * @param compareFunction - 比較関数
- * @returns マージされた新しい配列
+ * Helper function to merge two sorted arrays
+ * @param left Left array to merge
+ * @param right Right array to merge
+ * @param compareFunction Comparison function to determine order
+ * @returns New merged array in sorted order
  */
 function merge(left, right, compareFunction) {
   var array = [];

package/module/es5/Array/quickSort.d.ts

@@ -1,14 +1,15 @@
-type CompareFunction<T> = (a: T, b: T) => number;
+import type { CompareFunction } from "$/array/compareFunction";
 /**
- * 配列を高速にソート
- * QuickSortとInsertionSortを組み合わせたアルゴリズムで配列を高速にソートします
- * @param {T[]} array 配列
- * @param {CompareFunction<T>} compareFunction 比較関数
- * @param {number} startIndex 開始インデックス
- * @param {number} endIndex 終了インデックス
- * @param {number} insertionSortThreshold 挿入ソートの閾値
- * @returns T[]
- * @example quickSort([1, 3, 2, 4, 5], (a, b) => a - b); // [1, 2, 3, 4, 5]
+ * Sorts an array using a hybrid algorithm combining QuickSort and InsertionSort
+ * @param {T[]} array Array to sort
+ * @param {CompareFunction<T>} compareFunction Comparison function that returns negative if a < b, zero if a = b, positive if a > b
+ * @param {number} startIndex Starting index for the sort range (default: 0)
+ * @param {number} endIndex Ending index for the sort range (default: array.length - 1)
+ * @param {number} insertionSortThreshold Threshold for switching to insertion sort (default: 10)
+ * @returns {T[]} Sorted array
+ * @example
+ * quickSort([1, 3, 2, 4, 5]); // [1, 2, 3, 4, 5]
+ * quickSort([1, 3, 2], (a, b) => b - a); // [3, 2, 1]
+ * quickSort(['b', 'a', 'c']); // ['a', 'b', 'c']
  */
 export declare const quickSort: <T>(array: T[], compareFunction?: CompareFunction<T>, startIndex?: number, endIndex?: number, insertionSortThreshold?: number) => T[];
-export {};