@thi.ng/arrays 2.7.6 → 2.7.8

package/floyd-rivest.js

@@ -1,69 +1,49 @@
 import { compare } from "@thi.ng/compare/compare";
 import { swap } from "./swap.js";
-/**
- * Implementation of the Floyd-Rivest selection algorithm to partially find &
- * sort the `k`th smallest elements in given array, according to supplied
- * comparator.
- *
- * @remarks
- * `k` is the desired index value, where `buf[k]` is the `(k+1)`th smallest
- * element when `left=0` (default).
- *
- * **IMPORTANT:** Mutates (partially sorts) given array such that all items in
- * the `[left, k]` interval are the smallest.
- *
- * @example
- * ```ts
- * floydRivest([5, 3, -1, -10, 20, 7, 0, 4, 2], 3);
- * // [ -10, 0, -1, 2, 3,  4, 5, 20, 7 ]
- * ```
- *
- * Based on pseudo-code from:
- * - https://en.wikipedia.org/wiki/Floyd%E2%80%93Rivest_algorithm
- *
- * @param buf
- * @param k
- * @param cmp
- * @param left
- * @param right
- */
-export const floydRivest = (buf, k = 1, cmp = compare, left = 0, right = buf.length - 1) => {
-    while (right > left) {
-        // constants 600 & 0.5 are from original paper
-        if (right - left > 600) {
-            const n = right - left + 1;
-            const i = k - left + 1;
-            const z = Math.log(n);
-            const s = 0.5 * Math.exp(z * (2 / 3));
-            const sd = 0.5 * Math.sqrt(z * s * ((n - s) / n)) * Math.sign(i - n / 2);
-            floydRivest(buf, k, cmp, Math.max(left, (k - (i * s) / n + sd) | 0), Math.min(right, (k + ((n - i) * s) / n + sd) | 0));
-        }
-        const t = buf[k];
-        let i = left;
-        let j = right;
-        swap(buf, left, k);
-        if (cmp(buf[right], t) > 0)
-            swap(buf, right, left);
-        while (i < j) {
-            swap(buf, i, j);
-            i++;
-            j--;
-            while (compare(buf[i], t) < 0)
-                i++;
-            while (compare(buf[j], t) > 0)
-                j--;
-        }
-        if (compare(buf[left], t) === 0) {
-            swap(buf, left, j);
-        }
-        else {
-            j++;
-            swap(buf, j, right);
-        }
-        if (j <= k)
-            left = j + 1;
-        if (k <= j)
-            right = j - 1;
+const floydRivest = (buf, k = 1, cmp = compare, left = 0, right = buf.length - 1) => {
+  while (right > left) {
+    if (right - left > 600) {
+      const n = right - left + 1;
+      const i2 = k - left + 1;
+      const z = Math.log(n);
+      const s = 0.5 * Math.exp(z * (2 / 3));
+      const sd = 0.5 * Math.sqrt(z * s * ((n - s) / n)) * Math.sign(i2 - n / 2);
+      floydRivest(
+        buf,
+        k,
+        cmp,
+        Math.max(left, k - i2 * s / n + sd | 0),
+        Math.min(right, k + (n - i2) * s / n + sd | 0)
+      );
     }
-    return buf;
+    const t = buf[k];
+    let i = left;
+    let j = right;
+    swap(buf, left, k);
+    if (cmp(buf[right], t) > 0)
+      swap(buf, right, left);
+    while (i < j) {
+      swap(buf, i, j);
+      i++;
+      j--;
+      while (compare(buf[i], t) < 0)
+        i++;
+      while (compare(buf[j], t) > 0)
+        j--;
+    }
+    if (compare(buf[left], t) === 0) {
+      swap(buf, left, j);
+    } else {
+      j++;
+      swap(buf, j, right);
+    }
+    if (j <= k)
+      left = j + 1;
+    if (k <= j)
+      right = j - 1;
+  }
+  return buf;
+};
+export {
+  floydRivest
 };

package/fuzzy-match.js

@@ -1,40 +1,25 @@
 import { equiv as _eq } from "@thi.ng/equiv";
-/**
- * Performs a fuzzy search of `query` in `domain` and returns `true` if
- * successful.
- *
- * @remarks
- * The optional `equiv` predicate can be used to customize item equality
- * checking. Uses
- * [`equiv()`](https://docs.thi.ng/umbrella/equiv/functions/equiv.html) by
- * default.
- *
- * Adapted and generalized from: https://github.com/bevacqua/fufuzzyzzysearch
- * (MIT licensed)
- *
- * [`filterFuzzy()`](https://docs.thi.ng/umbrella/transducers/functions/filterFuzzy.html)
- *
- * @param domain - array
- * @param query - search value
- * @param equiv - equivalence predicate
- */
-export const fuzzyMatch = (domain, query, equiv = _eq) => {
-    const nd = domain.length;
-    const nq = query.length;
-    if (nq > nd) {
-        return false;
-    }
-    if (nq === nd) {
-        return equiv(query, domain);
-    }
-    next: for (let i = 0, j = 0; i < nq; i++) {
-        const q = query[i];
-        while (j < nd) {
-            if (equiv(domain[j++], q)) {
-                continue next;
-            }
+const fuzzyMatch = (domain, query, equiv = _eq) => {
+  const nd = domain.length;
+  const nq = query.length;
+  if (nq > nd) {
+    return false;
+  }
+  if (nq === nd) {
+    return equiv(query, domain);
+  }
+  next:
+    for (let i = 0, j = 0; i < nq; i++) {
+      const q = query[i];
+      while (j < nd) {
+        if (equiv(domain[j++], q)) {
+          continue next;
         }
-        return false;
+      }
+      return false;
     }
-    return true;
+  return true;
+};
+export {
+  fuzzyMatch
 };

package/insert.js

@@ -1,35 +1,12 @@
-/**
- * Inserts `x` into `buf` at index `i` and ensures that array length doesn't
- * grow beyond max `k` items (default: unbounded).
- *
- * @remarks
- * The function will have no effect iff `i<0` or `i>=k` or `k<1`. If
- * `buf.length` is larger than `k`, only the index range [i..k) will be
- * modified.
- *
- * In benchmarking with 4, 8, 16, 32, 64 element arrays, this function is
- * consistently 7-16x faster than `Array.prototype.copyWithin()` and 1.5-2x
- * faster than `Array.prototype.splice()` (for sizes < ~32). See
- * `/bench/insert.ts`
- *
- * @param buf -
- * @param x -
- * @param i -
- * @param k -
- */
-export const insert = (buf, x, i, k = Infinity) => i < 0 || i >= k || k < 1 ? buf : insertUnsafe(buf, x, i, k);
-/**
- * Same as {@link insert} but without any bounds/index checks.
- *
- * @param buf -
- * @param x -
- * @param i -
- * @param k -
- */
-export const insertUnsafe = (buf, x, i, k = Infinity) => {
-    let j = buf.length < k ? buf.length + 1 : k;
-    for (; --j > i;)
-        buf[j] = buf[j - 1];
-    buf[i] = x;
-    return buf;
+const insert = (buf, x, i, k = Infinity) => i < 0 || i >= k || k < 1 ? buf : insertUnsafe(buf, x, i, k);
+const insertUnsafe = (buf, x, i, k = Infinity) => {
+  let j = buf.length < k ? buf.length + 1 : k;
+  for (; --j > i; )
+    buf[j] = buf[j - 1];
+  buf[i] = x;
+  return buf;
+};
+export {
+  insert,
+  insertUnsafe
 };

package/into.js

@@ -1,16 +1,11 @@
-/**
- * Appends `max` items (default: all) from `src` iterable to `dest` array.
- * Returns `dest`.
- *
- * @param dest -
- * @param src -
- * @param max -
- */
-export const into = (dest, src, max = Infinity) => {
-    for (let x of src) {
-        if (--max < 0)
-            break;
-        dest.push(x);
-    }
-    return dest;
+const into = (dest, src, max = Infinity) => {
+  for (let x of src) {
+    if (--max < 0)
+      break;
+    dest.push(x);
+  }
+  return dest;
+};
+export {
+  into
 };

package/is-sorted.js

@@ -1,36 +1,14 @@
 import { compare } from "@thi.ng/compare/compare";
-/**
- * Returns true if the given array and its elements in the selected index range
- * (entire array, by default) are in the order defined by the given comparator
- * ([`compare()`](https://docs.thi.ng/umbrella/compare/functions/compare.html)
- * by default).
- *
- * @remarks
- * Always returns true, if effective index range (or array length) has less than
- * two elements. No bounds checking.
- *
- * @example
- * ```ts
- * isSorted([3, 2, 1])
- * // false
- *
- * // w/ custom comparator
- * isSorted([3, 2, 1], (a, b) => b - a)
- * // true
- * ```
- *
- * @param arr - array
- * @param cmp - comparator
- * @param start - start index
- * @param end - end index
- */
-export const isSorted = (arr, cmp = compare, start = 0, end = arr.length) => {
-    let prev = arr[start];
-    while (++start < end) {
-        const curr = arr[start];
-        if (cmp(prev, curr) > 0)
-            return false;
-        prev = curr;
-    }
-    return true;
+const isSorted = (arr, cmp = compare, start = 0, end = arr.length) => {
+  let prev = arr[start];
+  while (++start < end) {
+    const curr = arr[start];
+    if (cmp(prev, curr) > 0)
+      return false;
+    prev = curr;
+  }
+  return true;
+};
+export {
+  isSorted
 };

package/iterator.js

@@ -1,23 +1,13 @@
-/**
- * Returns iterator of nullable array w/ optional index range support
- * and/or reverse iteration order. The default range covers the entire
- * array.
- *
- * @remarks
- * If `start` > `end`, yields values in reverse order. No bounds
- * checking is performed.
- *
- * @param buf - array or null
- * @param start - start index
- * @param end - end index (excluded)
- */
-export function* arrayIterator(buf, start = 0, end) {
-    if (!buf)
-        return;
-    start = start;
-    end === undefined && (end = buf.length);
-    const step = start <= end ? 1 : -1;
-    for (; start !== end; start += step) {
-        yield buf[start];
-    }
+function* arrayIterator(buf, start = 0, end) {
+  if (!buf)
+    return;
+  start = start;
+  end === void 0 && (end = buf.length);
+  const step = start <= end ? 1 : -1;
+  for (; start !== end; start += step) {
+    yield buf[start];
+  }
 }
+export {
+  arrayIterator
+};

package/levenshtein.js

@@ -1,141 +1,95 @@
 const eqStrict = (a, b) => a === b;
-/**
- * Computes Levenshtein distance w/ optionally given `maxDist` (for
- * early termination, default: ∞) and equality predicate (default:
- * `===`). Returns 0 if both `a` and `b` are equal (based on predicate).
- * Returns `Infinity` if actual distance > `maxDist`.
- *
- * @remarks
- *
- * Based on:
- * - https://en.wikipedia.org/wiki/Levenshtein_distance
- * - https://en.wikipedia.org/wiki/Wagner%E2%80%93Fischer_algorithm
- * - https://github.com/gustf/js-levenshtein/blob/develop/index.js
- *
- * @example
- * ```ts
- * levenshtein([1, 2, 3, 4, 5], [1, 2, 4, 3, 5]);
- * // 2
- *
- * levenshtein(
- *   [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }],
- *   [{ id: 4 }, { id: 5 }, { id: 3 }, { id: 1 }, { id: 2 }],
- *   // max dist
- *   2,
- *   // predicate
- *   (a, b) => a.id === b.id
- * )
- * // Infinity
- * ```
- *
- * @param a -
- * @param b -
- * @param maxDist -
- * @param equiv -
- */
-export const levenshtein = (a, b, maxDist = Infinity, equiv = eqStrict) => {
-    if (a === b) {
-        return 0;
+const levenshtein = (a, b, maxDist = Infinity, equiv = eqStrict) => {
+  if (a === b) {
+    return 0;
+  }
+  if (a.length > b.length) {
+    const tmp = a;
+    a = b;
+    b = tmp;
+  }
+  let la = a.length;
+  let lb = b.length;
+  while (la > 0 && equiv(a[~-la], b[~-lb])) {
+    la--;
+    lb--;
+  }
+  let offset = 0;
+  while (offset < la && equiv(a[offset], b[offset])) {
+    offset++;
+  }
+  la -= offset;
+  lb -= offset;
+  if (la === 0 || lb < 3) {
+    return lb;
+  }
+  let x = 0;
+  let y;
+  let minDist;
+  let d0;
+  let d1;
+  let d2;
+  let d3;
+  let dd;
+  let dy;
+  let ay;
+  let bx0;
+  let bx1;
+  let bx2;
+  let bx3;
+  const _min = (d02, d12, d22, bx, ay2) => {
+    return d02 < d12 || d22 < d12 ? d02 > d22 ? d22 + 1 : d02 + 1 : equiv(ay2, bx) ? d12 : d12 + 1;
+  };
+  const vector = [];
+  for (y = 0; y < la; y++) {
+    vector.push(y + 1, a[offset + y]);
+  }
+  const len = vector.length - 1;
+  const lb3 = lb - 3;
+  for (; x < lb3; ) {
+    bx0 = b[offset + (d0 = x)];
+    bx1 = b[offset + (d1 = x + 1)];
+    bx2 = b[offset + (d2 = x + 2)];
+    bx3 = b[offset + (d3 = x + 3)];
+    dd = x += 4;
+    minDist = Infinity;
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y];
+      ay = vector[y + 1];
+      d0 = _min(dy, d0, d1, bx0, ay);
+      d1 = _min(d0, d1, d2, bx1, ay);
+      d2 = _min(d1, d2, d3, bx2, ay);
+      dd = _min(d2, d3, dd, bx3, ay);
+      dd < minDist && (minDist = dd);
+      vector[y] = dd;
+      d3 = d2;
+      d2 = d1;
+      d1 = d0;
+      d0 = dy;
     }
-    if (a.length > b.length) {
-        const tmp = a;
-        a = b;
-        b = tmp;
+    if (minDist > maxDist)
+      return Infinity;
+  }
+  for (; x < lb; ) {
+    bx0 = b[offset + (d0 = x)];
+    dd = ++x;
+    minDist = Infinity;
+    for (y = 0; y < len; y += 2) {
+      dy = vector[y];
+      vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
+      dd < minDist && (minDist = dd);
+      d0 = dy;
     }
-    let la = a.length;
-    let lb = b.length;
-    while (la > 0 && equiv(a[~-la], b[~-lb])) {
-        la--;
-        lb--;
-    }
-    let offset = 0;
-    while (offset < la && equiv(a[offset], b[offset])) {
-        offset++;
-    }
-    la -= offset;
-    lb -= offset;
-    if (la === 0 || lb < 3) {
-        return lb;
-    }
-    let x = 0;
-    let y;
-    let minDist;
-    let d0;
-    let d1;
-    let d2;
-    let d3;
-    let dd;
-    let dy;
-    let ay;
-    let bx0;
-    let bx1;
-    let bx2;
-    let bx3;
-    const _min = (d0, d1, d2, bx, ay) => {
-        return d0 < d1 || d2 < d1
-            ? d0 > d2
-                ? d2 + 1
-                : d0 + 1
-            : equiv(ay, bx)
-                ? d1
-                : d1 + 1;
-    };
-    const vector = [];
-    for (y = 0; y < la; y++) {
-        vector.push(y + 1, a[offset + y]);
-    }
-    const len = vector.length - 1;
-    const lb3 = lb - 3;
-    for (; x < lb3;) {
-        bx0 = b[offset + (d0 = x)];
-        bx1 = b[offset + (d1 = x + 1)];
-        bx2 = b[offset + (d2 = x + 2)];
-        bx3 = b[offset + (d3 = x + 3)];
-        dd = x += 4;
-        minDist = Infinity;
-        for (y = 0; y < len; y += 2) {
-            dy = vector[y];
-            ay = vector[y + 1];
-            d0 = _min(dy, d0, d1, bx0, ay);
-            d1 = _min(d0, d1, d2, bx1, ay);
-            d2 = _min(d1, d2, d3, bx2, ay);
-            dd = _min(d2, d3, dd, bx3, ay);
-            dd < minDist && (minDist = dd);
-            vector[y] = dd;
-            d3 = d2;
-            d2 = d1;
-            d1 = d0;
-            d0 = dy;
-        }
-        if (minDist > maxDist)
-            return Infinity;
-    }
-    for (; x < lb;) {
-        bx0 = b[offset + (d0 = x)];
-        dd = ++x;
-        minDist = Infinity;
-        for (y = 0; y < len; y += 2) {
-            dy = vector[y];
-            vector[y] = dd = _min(dy, d0, dd, bx0, vector[y + 1]);
-            dd < minDist && (minDist = dd);
-            d0 = dy;
-        }
-        if (minDist > maxDist)
-            return Infinity;
-    }
-    return dd;
+    if (minDist > maxDist)
+      return Infinity;
+  }
+  return dd;
+};
+const normalizedLevenshtein = (a, b, maxDist = Infinity, equiv = eqStrict) => {
+  const n = Math.max(a.length, b.length);
+  return n > 0 ? levenshtein(a, b, maxDist, equiv) / n : 0;
 };
-/**
- * Normalized version of {@link levenshtein}, i.e. the actual L-dist
- * divided by the length of the longest input (or `Infinity` if actual
- * distance > `maxDist`).
- *
- * @param a -
- * @param b -
- * @param maxDist -
- * @param equiv -
- */
-export const normalizedLevenshtein = (a, b, maxDist = Infinity, equiv = eqStrict) => {
-    const n = Math.max(a.length, b.length);
-    return n > 0 ? levenshtein(a, b, maxDist, equiv) / n : 0;
+export {
+  levenshtein,
+  normalizedLevenshtein
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/arrays",
-  "version": "2.7.6",
+  "version": "2.7.8",
   "description": "Array / Arraylike utilities",
   "type": "module",
   "module": "./index.js",
@@ -24,7 +24,9 @@
   "author": "Karsten Schmidt (https://thi.ng)",
   "license": "Apache-2.0",
   "scripts": {
-    "build": "yarn clean && tsc --declaration",
+    "build": "yarn build:esbuild && yarn build:decl",
+    "build:decl": "tsc --declaration --emitDeclarationOnly",
+    "build:esbuild": "esbuild --format=esm --platform=neutral --target=es2022 --tsconfig=tsconfig.json --outdir=. src/**/*.ts",
     "clean": "rimraf --glob '*.js' '*.d.ts' '*.map' doc",
     "doc": "typedoc --excludePrivate --excludeInternal --out doc src/index.ts",
     "doc:ae": "mkdir -p .ae/doc .ae/temp && api-extractor run --local --verbose",
@@ -33,16 +35,16 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@thi.ng/api": "^8.9.10",
-    "@thi.ng/checks": "^3.4.10",
-    "@thi.ng/compare": "^2.2.6",
-    "@thi.ng/equiv": "^2.1.35",
-    "@thi.ng/errors": "^2.4.4",
-    "@thi.ng/random": "^3.6.16"
+    "@thi.ng/api": "^8.9.12",
+    "@thi.ng/checks": "^3.4.12",
+    "@thi.ng/compare": "^2.2.8",
+    "@thi.ng/equiv": "^2.1.37",
+    "@thi.ng/errors": "^2.4.6",
+    "@thi.ng/random": "^3.6.18"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.38.3",
-    "@thi.ng/testament": "^0.4.3",
+    "esbuild": "^0.19.8",
     "rimraf": "^5.0.5",
     "tools": "^0.0.1",
     "typedoc": "^0.25.4",
@@ -164,5 +166,5 @@
   "thi.ng": {
     "year": 2018
   },
-  "gitHead": "04d1de79f256d7a53c6b5fd157b37f49bc88e11d\n"
+  "gitHead": "5e7bafedfc3d53bc131469a28de31dd8e5b4a3ff\n"
 }

package/peek.js

@@ -1,12 +1,6 @@
-/**
- * Returns first element of given array or `undefined` if array is empty.
- *
- * @param buf - array
- */
-export const first = (buf) => buf[0];
-/**
- * Returns last element of given array or `undefined` if array is empty.
- *
- * @param buf - array
- */
-export const peek = (buf) => buf[buf.length - 1];
+const first = (buf) => buf[0];
+const peek = (buf) => buf[buf.length - 1];
+export {
+  first,
+  peek
+};