umt 1.9.0 → 2.0.0

package/module/es5/Array/generateNumberArray.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateNumberArray = void 0;
+/**
+ * 指定された要素数まで数値型の配列を生成する
+ * @param length 配列の長さ
+ * @param min 最小値 (デフォルト: 0)
+ * @param max 最大値 (デフォルト: length - 1)
+ * @param random ランダムな値を生成するかどうか (デフォルト: false)
+ * @returns 数値型の配列
+ * @example generateNumberArray(5); // [0, 1, 2, 3, 4]
+ * @example generateNumberArray(5, 10, 14); // [10, 11, 12, 13, 14]
+ */
+var generateNumberArray = exports.generateNumberArray = function generateNumberArray(length) {
+  var min = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  var max = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : length - 1;
+  var random = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (length <= 0) {
+    return [];
+  }
+  if (min > max) {
+    throw new Error("min should be less than or equal to max");
+  }
+  if (length === 1) {
+    return [min];
+  }
+  if (random) {
+    return Array.from({
+      length: length
+    }, function () {
+      return Math.floor(Math.random() * (max - min + 1)) + min;
+    });
+  }
+  var step = (max - min) / (length - 1);
+  return Array.from({
+    length: length
+  }, function (_, index) {
+    return min + index * step;
+  });
+};

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

@@ -0,0 +1,8 @@
+/**
+ * 共通の要素を取り出す
+ * @param {T[]} array 最初の配列
+ * @param {T[][]} arrays 他の配列群
+ * @returns {O} 共通の要素を含む配列
+ * @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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getArraysCommon = void 0;
+/**
+ * 共通の要素を取り出す
+ * @param {T[]} array 最初の配列
+ * @param {T[][]} arrays 他の配列群
+ * @returns {O} 共通の要素を含む配列
+ * @example getArraysCommon([1, 2, 3], [2, 3, 4], [2, 5, 3]); // [2, 3]
+ */
+var getArraysCommon = exports.getArraysCommon = function getArraysCommon(array) {
+  for (var _len = arguments.length, arrays = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    arrays[_key - 1] = arguments[_key];
+  }
+  var result = [array].concat(arrays).reduce(function (previous, current) {
+    return previous.filter(function (item) {
+      return current.includes(item);
+    });
+  });
+  return result;
+};

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

@@ -0,0 +1,8 @@
+/**
+ * 共通しない要素をとりだす
+ * @param  {T[]} array
+ * @param  {T[]} arrays
+ * @returns unknown[]
+ * @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

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getArraysDiff = void 0;
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+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[]
+ * @example getArraysDiff([1, 2, 3], [2, 3, 4]); // [1, 4]
+ */
+var getArraysDiff = exports.getArraysDiff = function getArraysDiff(array) {
+  var allValues = new Set(array);
+  var duplicates = new Set();
+  for (var _len = arguments.length, arrays = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    arrays[_key - 1] = arguments[_key];
+  }
+  for (var _i = 0, _arrays = arrays; _i < _arrays.length; _i++) {
+    var array_ = _arrays[_i];
+    var _iterator = _createForOfIteratorHelper(array_),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var value = _step.value;
+        if (allValues.has(value)) {
+          duplicates.add(value);
+        } else {
+          allValues.add(value);
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  return _toConsumableArray(allValues).filter(function (value) {
+    return !duplicates.has(value);
+  });
+};

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

@@ -0,0 +1,7 @@
+/**
+ * 配列の要素をグループ化する
+ * @param array グループ化する配列
+ * @param iteratee 各要素に適用するグループ化関数
+ * @returns グループ化されたオブジェクト
+ */
+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

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.groupBy = void 0;
+/**
+ * 配列の要素をグループ化する
+ * @param array グループ化する配列
+ * @param iteratee 各要素に適用するグループ化関数
+ * @returns グループ化されたオブジェクト
+ */
+var groupBy = exports.groupBy = function groupBy(array, iteratee) {
+  return array.reduce(function (accumulator, value, index, array) {
+    var key = iteratee(value, index, array);
+    if (!accumulator[key]) {
+      accumulator[key] = [];
+    }
+    accumulator[key].push(value);
+    return accumulator;
+  }, {});
+};

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

@@ -0,0 +1,23 @@
+export * from "./arraysJoin";
+export * from "./binarySearch";
+export * from "./checkFlagAlignment";
+export * from "./chunk";
+export * from "./compact";
+export * from "./drop";
+export * from "./first";
+export * from "./generateNumberArray";
+export * from "./getArraysCommon";
+export * from "./getArraysDiff";
+export * from "./groupBy";
+export * from "./insertionSort";
+export * from "./mergeSort";
+export * from "./pop";
+export * from "./quickSort";
+export * from "./randomSelect";
+export * from "./range";
+export * from "./shuffle";
+export * from "./shuffle2DArray";
+export * from "./sum";
+export * from "./timSort";
+export * from "./zip";
+export * from "./zipLongest";

package/module/es5/Array/index.js

@@ -0,0 +1,258 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _arraysJoin = require("./arraysJoin");
+Object.keys(_arraysJoin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _arraysJoin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _arraysJoin[key];
+    }
+  });
+});
+var _binarySearch = require("./binarySearch");
+Object.keys(_binarySearch).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _binarySearch[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _binarySearch[key];
+    }
+  });
+});
+var _checkFlagAlignment = require("./checkFlagAlignment");
+Object.keys(_checkFlagAlignment).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _checkFlagAlignment[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _checkFlagAlignment[key];
+    }
+  });
+});
+var _chunk = require("./chunk");
+Object.keys(_chunk).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _chunk[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _chunk[key];
+    }
+  });
+});
+var _compact = require("./compact");
+Object.keys(_compact).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _compact[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _compact[key];
+    }
+  });
+});
+var _drop = require("./drop");
+Object.keys(_drop).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _drop[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _drop[key];
+    }
+  });
+});
+var _first = require("./first");
+Object.keys(_first).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _first[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _first[key];
+    }
+  });
+});
+var _generateNumberArray = require("./generateNumberArray");
+Object.keys(_generateNumberArray).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _generateNumberArray[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _generateNumberArray[key];
+    }
+  });
+});
+var _getArraysCommon = require("./getArraysCommon");
+Object.keys(_getArraysCommon).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getArraysCommon[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _getArraysCommon[key];
+    }
+  });
+});
+var _getArraysDiff = require("./getArraysDiff");
+Object.keys(_getArraysDiff).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getArraysDiff[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _getArraysDiff[key];
+    }
+  });
+});
+var _groupBy = require("./groupBy");
+Object.keys(_groupBy).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _groupBy[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _groupBy[key];
+    }
+  });
+});
+var _insertionSort = require("./insertionSort");
+Object.keys(_insertionSort).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _insertionSort[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _insertionSort[key];
+    }
+  });
+});
+var _mergeSort = require("./mergeSort");
+Object.keys(_mergeSort).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _mergeSort[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _mergeSort[key];
+    }
+  });
+});
+var _pop = require("./pop");
+Object.keys(_pop).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pop[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _pop[key];
+    }
+  });
+});
+var _quickSort = require("./quickSort");
+Object.keys(_quickSort).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _quickSort[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _quickSort[key];
+    }
+  });
+});
+var _randomSelect = require("./randomSelect");
+Object.keys(_randomSelect).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _randomSelect[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _randomSelect[key];
+    }
+  });
+});
+var _range = require("./range");
+Object.keys(_range).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _range[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _range[key];
+    }
+  });
+});
+var _shuffle = require("./shuffle");
+Object.keys(_shuffle).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _shuffle[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _shuffle[key];
+    }
+  });
+});
+var _shuffle2DArray = require("./shuffle2DArray");
+Object.keys(_shuffle2DArray).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _shuffle2DArray[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _shuffle2DArray[key];
+    }
+  });
+});
+var _sum = require("./sum");
+Object.keys(_sum).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _sum[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _sum[key];
+    }
+  });
+});
+var _timSort = require("./timSort");
+Object.keys(_timSort).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _timSort[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _timSort[key];
+    }
+  });
+});
+var _zip = require("./zip");
+Object.keys(_zip).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _zip[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _zip[key];
+    }
+  });
+});
+var _zipLongest = require("./zipLongest");
+Object.keys(_zipLongest).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _zipLongest[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _zipLongest[key];
+    }
+  });
+});

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

@@ -0,0 +1,22 @@
+/**
+ * 挿入ソートを使用して配列をソート
+ *
+ * @param array ソートする配列
+ * @param compareFunction 比較関数
+ * @param start ソートを開始する配列のインデックス
+ * @param end ソートを終了する配列のインデックス
+ * @returns ソートされた配列
+ *
+ * @example
+ * const numbers = [4, 2, 7, 1, 3];
+ * insertionSort(numbers); // [1, 2, 3, 4, 7]
+ *
+ * @example
+ * const numbers = [4, 2, 7, 1, 3];
+ * insertionSort(numbers, (a, b) => a - b); // [1, 2, 3, 4, 7]
+ *
+ * @example
+ * 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[];

package/module/es5/Array/insertionSort.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.insertionSort = void 0;
+var _compareFunctionDefault = require("./compareFunctionDefault");
+/**
+ * 挿入ソートを使用して配列をソート
+ *
+ * @param array ソートする配列
+ * @param compareFunction 比較関数
+ * @param start ソートを開始する配列のインデックス
+ * @param end ソートを終了する配列のインデックス
+ * @returns ソートされた配列
+ *
+ * @example
+ * const numbers = [4, 2, 7, 1, 3];
+ * insertionSort(numbers); // [1, 2, 3, 4, 7]
+ *
+ * @example
+ * const numbers = [4, 2, 7, 1, 3];
+ * insertionSort(numbers, (a, b) => a - b); // [1, 2, 3, 4, 7]
+ *
+ * @example
+ * const numbers = [4, 2, 7, 1, 3];
+ * insertionSort(numbers, undefined, 1, 3); // [4, 1, 2, 7, 3]
+ */
+var insertionSort = exports.insertionSort = function insertionSort(array) {
+  var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
+  var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var end = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
+  for (var index = start + 1; index <= end; index++) {
+    var index_ = index;
+    var target = array[index];
+    while (index_ > start && compareFunction(array[index_ - 1], target) > 0) {
+      array[index_] = array[index_ - 1];
+      index_--;
+    }
+    array[index_] = target;
+  }
+  return array;
+};

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

@@ -0,0 +1,8 @@
+/**
+ * マージソート
+ * @param  {T[]} array 配列
+ * @param  {(a: T, b: T) => number} compareFunction 比較関数
+ * @returns T[]
+ * @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[];

package/module/es5/Array/mergeSort.js

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeSort = void 0;
+var _compareFunctionDefault = require("./compareFunctionDefault");
+/**
+ * マージソート
+ * @param  {T[]} array 配列
+ * @param  {(a: T, b: T) => number} compareFunction 比較関数
+ * @returns T[]
+ * @example mergeSort([1, 3, 2, 4, 5], (a, b) => a - b); // [1, 2, 3, 4, 5]
+ */
+var _mergeSort = exports.mergeSort = function mergeSort(array) {
+  var compareFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _compareFunctionDefault.compareFunctionDefault;
+  if (array.length <= 1) {
+    return array;
+  }
+  var middle = Math.floor(array.length / 2);
+  var left = array.slice(0, middle);
+  var right = array.slice(middle);
+  return merge(_mergeSort(left, compareFunction), _mergeSort(right, compareFunction), compareFunction);
+};
+
+/**
+ * 2つの配列をマージする関数
+ * @param left - マージする左の配列
+ * @param right - マージする右の配列
+ * @param compareFunction - 比較関数
+ * @returns マージされた新しい配列
+ */
+function merge(left, right, compareFunction) {
+  var array = [];
+  var lIndex = 0;
+  var rIndex = 0;
+  while (lIndex < left.length && rIndex < right.length) {
+    if (compareFunction(left[lIndex], right[rIndex]) <= 0) {
+      array.push(left[lIndex++]);
+    } else {
+      array.push(right[rIndex++]);
+    }
+  }
+  return array.concat(left.slice(lIndex)).concat(right.slice(rIndex));
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Removes the last element from an array and returns it.
+ * @param {T[]} array - The array to remove the last element from.
+ * @returns {T | undefined} - The last element of the array, or undefined if the array is empty.
+ */
+export declare const pop: <T>(array: T[]) => T | undefined;

package/module/es5/Array/pop.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pop = void 0;
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+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 _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+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; }
+/**
+ * Removes the last element from an array and returns it.
+ * @param {T[]} array - The array to remove the last element from.
+ * @returns {T | undefined} - The last element of the array, or undefined if the array is empty.
+ */
+var pop = exports.pop = function pop(array) {
+  return _toConsumableArray(array).pop();
+};

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

@@ -0,0 +1,14 @@
+type CompareFunction<T> = (a: T, b: T) => number;
+/**
+ * 配列を高速にソート
+ * 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]
+ */
+export declare const quickSort: <T>(array: T[], compareFunction?: CompareFunction<T>, startIndex?: number, endIndex?: number, insertionSortThreshold?: number) => T[];
+export {};