@thi.ng/arrays 2.7.7 → 2.7.8

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-09T19:12:03Z
+- **Last updated**: 2023-12-11T10:07:09Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.

package/api.js

@@ -1 +0,0 @@
-export {};

package/arg-sort.js

@@ -1,31 +1,7 @@
 import { compare } from "@thi.ng/compare/compare";
 import { fillRange } from "./fill-range.js";
 import { sortByCachedKey } from "./sort-cached.js";
-/**
- * Returns a new array of numeric indices in same order as sorted values of
- * `src` using given (optional) comparator (default: thi.ng/compare). The `src`
- * array will remain unmodified.
- *
- * @remarks
- * Also see {@link swizzle} to read an array in custom order.
- *
- * @example
- * ```ts
- * const src = ["a", "c", "d", "b"];
- *
- * argSort(src)
- * // [ 0, 3, 1, 2 ]
- *
- * // src[0] => "a"
- * // src[3] => "b"
- * // src[1] => "c"
- * // src[2] => "d"
- *
- * swizzle(argSort(src))(src)
- * // [ 'a', 'b', 'c', 'd' ]
- * ```
- *
- * @param src -
- * @param cmp -
- */
-export const argSort = (src, cmp = compare) => sortByCachedKey(fillRange(new Array(src.length)), src.slice(), cmp);
+const argSort = (src, cmp = compare) => sortByCachedKey(fillRange(new Array(src.length)), src.slice(), cmp);
+export {
+  argSort
+};

package/argmin.js

@@ -1,42 +1,16 @@
-/**
- * Takes an array of numbers and returns the index of the item which is
- * considered the minimum value according to the given initial `min` value
- * (default: ∞) and predicate (both optional). Returns -1 if `items` is empty.
- *
- * @remarks
- * See {@link argMax}.
- *
- * @example
- * ```ts
- * argMin([42, 11, 66, 23])
- * // 1
- *
- * // same as argmax() with defaults
- * argMin([42, 11, 66, 23], -Infinity, (a, b) => a > b)
- * // 2
- * ```
- *
- * @param buf
- * @param min
- * @param pred
- */
-export const argMin = (buf, min = Infinity, pred = (a, b) => a < b) => {
-    let id = -1;
-    for (let i = 0, n = buf.length; i < n; i++) {
-        const x = buf[i];
-        if (pred(x, min)) {
-            min = x;
-            id = i;
-        }
+const argMin = (buf, min = Infinity, pred = (a, b) => a < b) => {
+  let id = -1;
+  for (let i = 0, n = buf.length; i < n; i++) {
+    const x = buf[i];
+    if (pred(x, min)) {
+      min = x;
+      id = i;
     }
-    return id;
+  }
+  return id;
+};
+const argMax = (items, min = -Infinity, pred = (a, b) => a > b) => argMin(items, min, pred);
+export {
+  argMax,
+  argMin
 };
-/**
- * Similar to {@link argMin}, but selects index of maximum item. Returns -1 if
- * `items` is empty.
- *
- * @param items
- * @param min
- * @param pred
- */
-export const argMax = (items, min = -Infinity, pred = (a, b) => a > b) => argMin(items, min, pred);

package/binary-search.js

@@ -1,187 +1,80 @@
 import { compare } from "@thi.ng/compare/compare";
 import { compareNumAsc } from "@thi.ng/compare/numeric";
-/**
- * Returns the supposed index of `x` in pre-sorted array-like collection `buf`.
- *
- * @remarks
- * If `x` can't be found, returns `-index-1`, representing the negative of the
- * index, were `x` to be inserted into `buf`. E.g if the return value is -3, `x`
- * would appear/insert at index 2.
- *
- * The optional `key` function is used to obtain the actual sort value of `x`
- * and each array item (default: identity).
- *
- * The optional `cmp` comparator (default:
- * [`compare()`](https://docs.thi.ng/umbrella/compare/functions/compare.html))
- * is then used to identify the index of `x`. The sort order of `buf` MUST be
- * compatible with that of `cmp`.
- *
- * @example
- * ```ts
- * binarySearch([2, 4, 6], 5);
- * // -3
- * ```
- *
- * @param buf - array
- * @param x - search value
- * @param key - key function
- * @param cmp - comparator
- * @param low - min index
- * @param high - max index
- */
-export const binarySearch = (buf, x, key = (x) => x, cmp = compare, low = 0, high = buf.length - 1) => {
-    const kx = key(x);
-    while (low <= high) {
-        const mid = (low + high) >>> 1;
-        const c = cmp(key(buf[mid]), kx);
-        if (c < 0) {
-            low = mid + 1;
-        }
-        else if (c > 0) {
-            high = mid - 1;
-        }
-        else {
-            return mid;
-        }
+const binarySearch = (buf, x, key = (x2) => x2, cmp = compare, low = 0, high = buf.length - 1) => {
+  const kx = key(x);
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const c = cmp(key(buf[mid]), kx);
+    if (c < 0) {
+      low = mid + 1;
+    } else if (c > 0) {
+      high = mid - 1;
+    } else {
+      return mid;
     }
-    return -low - 1;
+  }
+  return -low - 1;
 };
-/**
- * Similar to {@link binarySearch}, but optimized for numeric arrays and
- * supporting custom comparators (default:
- * [`compareNumAsc()`](https://docs.thi.ng/umbrella/compare/functions/compareNumAsc.html)).
- *
- * @param buf - array
- * @param x - search value
- * @param cmp - comparator
- * @param low - min index
- * @param high - max index
- */
-export const binarySearchNumeric = (buf, x, cmp = compareNumAsc, low = 0, high = buf.length - 1) => {
-    while (low <= high) {
-        const mid = (low + high) >>> 1;
-        const c = cmp(buf[mid], x);
-        if (c < 0) {
-            low = mid + 1;
-        }
-        else if (c > 0) {
-            high = mid - 1;
-        }
-        else {
-            return mid;
-        }
+const binarySearchNumeric = (buf, x, cmp = compareNumAsc, low = 0, high = buf.length - 1) => {
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const c = cmp(buf[mid], x);
+    if (c < 0) {
+      low = mid + 1;
+    } else if (c > 0) {
+      high = mid - 1;
+    } else {
+      return mid;
     }
-    return -low - 1;
+  }
+  return -low - 1;
 };
-export const binarySearch2 = (buf, x) => {
-    let idx = buf[1] <= x ? 1 : 0;
-    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
+const binarySearch2 = (buf, x) => {
+  let idx = buf[1] <= x ? 1 : 0;
+  return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
 };
-/**
- * Non-recursive, optimized binary search for fixed size numeric arrays of 4
- * values. Returns index of `x` or `-index-1` if not found.
- *
- * @param buf -
- * @param x -
- */
-export const binarySearch4 = (buf, x) => {
-    let idx = buf[2] <= x ? 2 : 0;
-    idx |= buf[idx + 1] <= x ? 1 : 0;
-    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
+const binarySearch4 = (buf, x) => {
+  let idx = buf[2] <= x ? 2 : 0;
+  idx |= buf[idx + 1] <= x ? 1 : 0;
+  return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
 };
-/**
- * Non-recursive, optimized binary search for fixed size numeric arrays of 8
- * values. Returns index of `x` or `-index-1` if not found.
- *
- * @param buf -
- * @param x -
- */
-export const binarySearch8 = (buf, x) => {
-    let idx = buf[4] <= x ? 4 : 0;
-    idx |= buf[idx + 2] <= x ? 2 : 0;
-    idx |= buf[idx + 1] <= x ? 1 : 0;
-    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
+const binarySearch8 = (buf, x) => {
+  let idx = buf[4] <= x ? 4 : 0;
+  idx |= buf[idx + 2] <= x ? 2 : 0;
+  idx |= buf[idx + 1] <= x ? 1 : 0;
+  return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
 };
-/**
- * Non-recursive, optimized binary search for fixed size numeric arrays of 16
- * values. Returns index of `x` or `-index-1` if not found.
- *
- * @param buf -
- * @param x -
- */
-export const binarySearch16 = (buf, x) => {
-    let idx = buf[8] <= x ? 8 : 0;
-    idx |= buf[idx + 4] <= x ? 4 : 0;
-    idx |= buf[idx + 2] <= x ? 2 : 0;
-    idx |= buf[idx + 1] <= x ? 1 : 0;
-    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
+const binarySearch16 = (buf, x) => {
+  let idx = buf[8] <= x ? 8 : 0;
+  idx |= buf[idx + 4] <= x ? 4 : 0;
+  idx |= buf[idx + 2] <= x ? 2 : 0;
+  idx |= buf[idx + 1] <= x ? 1 : 0;
+  return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
 };
-/**
- * Non-recursive, optimized binary search for fixed size numeric arrays of 32
- * values. Returns index of `x` or `-index-1` if not found.
- *
- * @param buf -
- * @param x -
- */
-export const binarySearch32 = (buf, x) => {
-    let idx = buf[16] <= x ? 16 : 0;
-    idx |= buf[idx + 4] <= x ? 8 : 0;
-    idx |= buf[idx + 4] <= x ? 4 : 0;
-    idx |= buf[idx + 2] <= x ? 2 : 0;
-    idx |= buf[idx + 1] <= x ? 1 : 0;
-    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
+const binarySearch32 = (buf, x) => {
+  let idx = buf[16] <= x ? 16 : 0;
+  idx |= buf[idx + 4] <= x ? 8 : 0;
+  idx |= buf[idx + 4] <= x ? 4 : 0;
+  idx |= buf[idx + 2] <= x ? 2 : 0;
+  idx |= buf[idx + 1] <= x ? 1 : 0;
+  return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;
+};
+const bsLT = (i) => i < 0 ? -i - 2 : i - 1;
+const bsLE = (i) => i < 0 ? -i - 2 : i;
+const bsGT = (i, n) => (i = i < 0 ? -i - 1 : i + 1, i < n ? i : -1);
+const bsGE = (i, n) => (i = i < 0 ? -i - 1 : i, i < n ? i : -1);
+const bsEQ = (i) => i < 0 ? -1 : i;
+export {
+  binarySearch,
+  binarySearch16,
+  binarySearch2,
+  binarySearch32,
+  binarySearch4,
+  binarySearch8,
+  binarySearchNumeric,
+  bsEQ,
+  bsGE,
+  bsGT,
+  bsLE,
+  bsLT
 };
-/**
- * {@link binarySearch} result index classifier for predecessor queries.
- * Returns index of last item less than search value or -1 if no such
- * values exist.
- *
- * @example
- * ```ts
- * bsLT(binarySearch([10, 20, 30, 40], 25))
- * // 1
- * ```
- *
- * @param i - binarySearch result index
- */
-export const bsLT = (i) => (i < 0 ? -i - 2 : i - 1);
-/**
- * Similar to {@link bsLT}, but for less-than-equals queries.
- *
- * @param i - binarySearch result index
- */
-export const bsLE = (i) => (i < 0 ? -i - 2 : i);
-/**
- * {@link binarySearch} result index classifier for successor queries.
- * Returns index of first item greater than search value or -1 if no
- * such values exist.
- *
- * @example
- * ```ts
- * src = [10, 20, 30, 40];
- *
- * bsGT(binarySearch(src, 25), src.length)
- * // 2
- *
- * bsGT(binarySearch(src, 40), src.length)
- * // -1
- * ```
- *
- * @param i - binarySearch result index
- * @param n - array length
- */
-export const bsGT = (i, n) => ((i = i < 0 ? -i - 1 : i + 1), i < n ? i : -1);
-/**
- * Similar to {@link bsGT}, but for greater-than-equals queries.
- *
- * @param i - binarySearch result index
- * @param n - array length
- */
-export const bsGE = (i, n) => ((i = i < 0 ? -i - 1 : i), i < n ? i : -1);
-/**
- * {@link binarySearch} result index classifier for equals queries.
- * Merely syntax sugar, casting any non-found result indices to -1.
- *
- * @param i - binarySearch result index
- */
-export const bsEQ = (i) => (i < 0 ? -1 : i);

package/bisect.js

@@ -1,23 +1,12 @@
-/**
- * Splits array at given index (default: floor(src.length/2)) and returns tuple of [lhs, rhs].
- *
- * @param src -
- * @param i -
- */
-export const bisect = (src, i = src.length >>> 1) => [
-    src.slice(0, i),
-    src.slice(i),
+const bisect = (src, i = src.length >>> 1) => [
+  src.slice(0, i),
+  src.slice(i)
 ];
-/**
- * Similar to {@link bisect}, but first finds split index via provided
- * predicate. The item for which the predicate first returns a truthy result,
- * will be the first item in the RHS array. If the predicate never succeeds, the
- * function returns `[src, []]`, i.e. all items will remain in the LHS.
- *
- * @param src -
- * @param pred -
- */
-export const bisectWith = (src, pred) => {
-    const i = src.findIndex(pred);
-    return i >= 0 ? bisect(src, i) : [src, []];
+const bisectWith = (src, pred) => {
+  const i = src.findIndex(pred);
+  return i >= 0 ? bisect(src, i) : [src, []];
+};
+export {
+  bisect,
+  bisectWith
 };

package/blit.js

@@ -1,36 +1,39 @@
-export function blit1d(dest, x, src, mask) {
-    const [sx, sw, dx, dw] = __clip(0, src.length, x, dest.length);
-    if (sw < 1 || dx >= dw)
-        return dest;
-    for (let i = 0; i < sw; i++) {
-        const val = src[sx + i];
-        val !== mask && (dest[dx + i] = val);
-    }
+function blit1d(dest, x, src, mask) {
+  const [sx, sw, dx, dw] = __clip(0, src.length, x, dest.length);
+  if (sw < 1 || dx >= dw)
     return dest;
+  for (let i = 0; i < sw; i++) {
+    const val = src[sx + i];
+    val !== mask && (dest[dx + i] = val);
+  }
+  return dest;
 }
-export function blit2d(dest, dpos, dsize, src, ssize, mask) {
-    const [sx, sw, dx, dw] = __clip(0, ssize[0], dpos[0], dsize[0]);
-    const [sy, sh, dy, dh] = __clip(0, ssize[1], dpos[1], dsize[1]);
-    if (sw < 1 || sh < 1 || dx >= dw || dy >= dh)
-        return dest;
-    const sstride = ssize[0];
-    const dstride = dsize[0];
-    for (let y = 0; y < sh; y++) {
-        for (let x = 0, soff = (sy + y) * sstride + sx, doff = (dy + y) * dstride + dx; x < sw; x++) {
-            const val = src[soff + x];
-            val !== mask && (dest[doff + x] = val);
-        }
-    }
+function blit2d(dest, dpos, dsize, src, ssize, mask) {
+  const [sx, sw, dx, dw] = __clip(0, ssize[0], dpos[0], dsize[0]);
+  const [sy, sh, dy, dh] = __clip(0, ssize[1], dpos[1], dsize[1]);
+  if (sw < 1 || sh < 1 || dx >= dw || dy >= dh)
     return dest;
+  const sstride = ssize[0];
+  const dstride = dsize[0];
+  for (let y = 0; y < sh; y++) {
+    for (let x = 0, soff = (sy + y) * sstride + sx, doff = (dy + y) * dstride + dx; x < sw; x++) {
+      const val = src[soff + x];
+      val !== mask && (dest[doff + x] = val);
+    }
+  }
+  return dest;
 }
 const __clip = (sx, sw, dx, dw) => {
-    if (dx < 0) {
-        sx -= dx;
-        sw += dx;
-        dx = 0;
-    }
-    else if (dx + sw > dw) {
-        sw = dw - dx;
-    }
-    return [sx, sw, dx, dw];
+  if (dx < 0) {
+    sx -= dx;
+    sw += dx;
+    dx = 0;
+  } else if (dx + sw > dw) {
+    sw = dw - dx;
+  }
+  return [sx, sw, dx, dw];
+};
+export {
+  blit1d,
+  blit2d
 };

package/ends-with.js

@@ -1,26 +1,13 @@
 import { equiv as _eq } from "@thi.ng/equiv";
-/**
- * Returns true if the last items of `buf` are the same items as in `needle`.
- *
- * @remarks
- * This means `buf` should have at least the same length as `needle` for this to
- * be true.
- *
- * By default, uses
- * [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) for
- * equality checking.
- *
- * {@link startsWith}
- *
- * @param buf - array
- * @param needle - search values (array)
- * @param equiv - equivalence predicate
- */
-export const endsWith = (buf, needle, equiv = _eq) => {
-    let i = buf.length;
-    let j = needle.length;
-    if (i < j)
-        return false;
-    while ((--i, j-- > 0 && equiv(buf[i], needle[j]))) { }
-    return j < 0;
+const endsWith = (buf, needle, equiv = _eq) => {
+  let i = buf.length;
+  let j = needle.length;
+  if (i < j)
+    return false;
+  while (--i, j-- > 0 && equiv(buf[i], needle[j])) {
+  }
+  return j < 0;
+};
+export {
+  endsWith
 };

package/ensure-array.js

@@ -1,23 +1,9 @@
 import { isArray } from "@thi.ng/checks/is-array";
 import { isArrayLike } from "@thi.ng/checks/is-arraylike";
 import { ensureIterable } from "./ensure-iterable.js";
-/**
- * Helper function to avoid unnecessary copying if `x` is already an
- * array.
- *
- * @remarks
- * First checks if `x` is an array and if so returns it. Else attempts
- * to obtain an iterator from `x` and if successful collects it as array
- * and returns it. Throws error if `x` isn't iterable.
- *
- * @param x -
- */
-export const ensureArray = (x) => isArray(x) ? x : [...ensureIterable(x)];
-/**
- * Similar to {@link ensureArray}, but for `ArrayLike` types.
- *
- * {@link ensureArray}
- *
- * @param x -
- */
-export const ensureArrayLike = (x) => isArrayLike(x) ? x : [...ensureIterable(x)];
+const ensureArray = (x) => isArray(x) ? x : [...ensureIterable(x)];
+const ensureArrayLike = (x) => isArrayLike(x) ? x : [...ensureIterable(x)];
+export {
+  ensureArray,
+  ensureArrayLike
+};

package/ensure-iterable.js

@@ -1,12 +1,8 @@
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
-/**
- * Attempts to obtain an iterator from `x` and throws error if `x` is
- * not iterable.
- *
- * @param x -
- */
-export const ensureIterable = (x) => {
-    (x == null || !x[Symbol.iterator]) &&
-        illegalArgs(`value is not iterable: ${x}`);
-    return x;
+const ensureIterable = (x) => {
+  (x == null || !x[Symbol.iterator]) && illegalArgs(`value is not iterable: ${x}`);
+  return x;
+};
+export {
+  ensureIterable
 };

package/fill-range.js

@@ -1,34 +1,13 @@
-/**
- * Fills given array with values in [start .. end) interval from `index`
- * and with optional `step` size.
- *
- * @remarks
- * `start` and `end` default to 0 and array length, `step` defaults to 1
- * or -1 (depending on range). Returns array.
- *
- * @example
- * ```ts
- * fillRange(new Array(5))
- * // [ 0, 1, 2, 3, 4 ]
- *
- * fillRange(fillRange([], 0, 10, 20, 2), 5, 20, 8, -2)
- * // [ 10, 12, 14, 16, 18, 20, 18, 16, 14, 12, 10 ]
- * ```
- *
- * @param buf -
- * @param index -
- * @param start -
- * @param end -
- * @param step -
- */
-export const fillRange = (buf, index = 0, start = 0, end = buf.length, step = end > start ? 1 : -1) => {
-    if (step > 0) {
-        for (; start < end; start += step)
-            buf[index++] = start;
-    }
-    else {
-        for (; start > end; start += step)
-            buf[index++] = start;
-    }
-    return buf;
+const fillRange = (buf, index = 0, start = 0, end = buf.length, step = end > start ? 1 : -1) => {
+  if (step > 0) {
+    for (; start < end; start += step)
+      buf[index++] = start;
+  } else {
+    for (; start > end; start += step)
+      buf[index++] = start;
+  }
+  return buf;
+};
+export {
+  fillRange
 };

package/find.js

@@ -1,29 +1,16 @@
 import { equiv as _equiv } from "@thi.ng/equiv";
-/**
- * Similar to `Array.find()`, but uses [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) as
- * default predicate.
- *
- * @param buf - array
- * @param x - search value
- * @param equiv - equivalence predicate
- */
-export const find = (buf, x, equiv = _equiv) => {
-    const i = findIndex(buf, x, equiv);
-    return i !== -1 ? buf[i] : undefined;
+const find = (buf, x, equiv = _equiv) => {
+  const i = findIndex(buf, x, equiv);
+  return i !== -1 ? buf[i] : void 0;
 };
-/**
- * Similar to `Array.findIndex()`, but uses
- * [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) as
- * default predicate.
- *
- * @param buf - array
- * @param x - search value
- * @param equiv - equivalence predicate
- */
-export const findIndex = (buf, x, equiv = _equiv) => {
-    for (let i = buf.length; i-- > 0;) {
-        if (equiv(x, buf[i]))
-            return i;
-    }
-    return -1;
+const findIndex = (buf, x, equiv = _equiv) => {
+  for (let i = buf.length; i-- > 0; ) {
+    if (equiv(x, buf[i]))
+      return i;
+  }
+  return -1;
+};
+export {
+  find,
+  findIndex
 };