@thi.ng/transducers 8.8.13 → 8.8.15

package/permutations.js

@@ -1,64 +1,41 @@
 import { ensureArrayLike } from "@thi.ng/arrays/ensure-array";
 import { illegalArgs } from "@thi.ng/errors/illegal-arguments";
 import { range } from "./range.js";
-export function* permutations(...src) {
-    const n = src.length - 1;
-    if (n < 0) {
-        return;
-    }
-    const step = new Array(n + 1).fill(0);
-    const realized = src.map(ensureArrayLike);
-    const total = realized.reduce((acc, x) => acc * x.length, 1);
-    for (let i = 0; i < total; i++) {
-        const tuple = [];
-        for (let j = n; j >= 0; j--) {
-            const r = realized[j];
-            let s = step[j];
-            if (s === r.length) {
-                step[j] = s = 0;
-                j > 0 && step[j - 1]++;
-            }
-            tuple[j] = r[s];
-        }
-        step[n]++;
-        yield tuple;
+function* permutations(...src) {
+  const n = src.length - 1;
+  if (n < 0) {
+    return;
+  }
+  const step = new Array(n + 1).fill(0);
+  const realized = src.map(ensureArrayLike);
+  const total = realized.reduce((acc, x) => acc * x.length, 1);
+  for (let i = 0; i < total; i++) {
+    const tuple = [];
+    for (let j = n; j >= 0; j--) {
+      const r = realized[j];
+      let s = step[j];
+      if (s === r.length) {
+        step[j] = s = 0;
+        j > 0 && step[j - 1]++;
+      }
+      tuple[j] = r[s];
     }
+    step[n]++;
+    yield tuple;
+  }
 }
-/**
- * Iterator yielding the Cartesian Product for `n` items of `m` values
- * each.
- *
- * @remarks
- * If `m` is not given, defaults to value of `n`. The range of `m` is
- * `0..m-1`. The optional `offsets` array can be used to define start
- * values for each dimension.
- *
- * @example
- * ```ts
- * [...permutationsN(2)]
- * // [ [0, 0], [0, 1], [1, 0], [1, 1] ]
- *
- * [...permutationsN(2, 3)]
- * // [ [0, 0], [0, 1], [0, 2],
- * //   [1, 0], [1, 1], [1, 2],
- * //   [2, 0], [2, 1], [2, 2] ]
- *
- * [...permutationsN(2, 2, [10, 20])]
- * // [ [ 10, 20 ], [ 10, 21 ], [ 11, 20 ], [ 11, 21 ] ]
- * ```
- *
- * @param n -
- * @param m -
- * @param offsets -
- */
-export const permutationsN = (n, m = n, offsets) => {
-    if (offsets && offsets.length < n) {
-        illegalArgs(`insufficient offsets, got ${offsets.length}, needed ${n}`);
-    }
-    const seqs = [];
-    while (n-- > 0) {
-        const o = offsets ? offsets[n] : 0;
-        seqs[n] = range(o, o + m);
-    }
-    return permutations.apply(null, seqs);
+const permutationsN = (n, m = n, offsets) => {
+  if (offsets && offsets.length < n) {
+    illegalArgs(`insufficient offsets, got ${offsets.length}, needed ${n}`);
+  }
+  const seqs = [];
+  while (n-- > 0) {
+    const o = offsets ? offsets[n] : 0;
+    seqs[n] = range(o, o + m);
+  }
+  return permutations.apply(null, seqs);
+};
+export {
+  permutations,
+  permutationsN
 };

package/pluck.js

@@ -1,8 +1,9 @@
 import { isIterable } from "@thi.ng/checks/is-iterable";
 import { iterator1 } from "./iterator.js";
 import { map } from "./map.js";
-export function pluck(key, src) {
-    return isIterable(src)
-        ? iterator1(pluck(key), src)
-        : map((x) => x[key]);
+function pluck(key, src) {
+  return isIterable(src) ? iterator1(pluck(key), src) : map((x) => x[key]);
 }
+export {
+  pluck
+};

package/push-copy.js

@@ -1,2 +1,8 @@
 import { reducer } from "./reduce.js";
-export const pushCopy = () => reducer(() => [], (acc, x) => ((acc = acc.slice()).push(x), acc));
+const pushCopy = () => reducer(
+  () => [],
+  (acc, x) => ((acc = acc.slice()).push(x), acc)
+);
+export {
+  pushCopy
+};

package/push-sort.js

@@ -1,10 +1,11 @@
 import { compare } from "@thi.ng/compare/compare";
-export function pushSort(cmp = compare, xs) {
-    return xs
-        ? [...xs].sort(cmp)
-        : [
-            () => [],
-            (acc) => acc.sort(cmp),
-            (acc, x) => (acc.push(x), acc),
-        ];
+function pushSort(cmp = compare, xs) {
+  return xs ? [...xs].sort(cmp) : [
+    () => [],
+    (acc) => acc.sort(cmp),
+    (acc, x) => (acc.push(x), acc)
+  ];
 }
+export {
+  pushSort
+};

package/push.js

@@ -1,6 +1,10 @@
 import { reducer } from "./reduce.js";
-export function push(xs) {
-    return xs
-        ? [...xs]
-        : reducer(() => [], (acc, x) => (acc.push(x), acc));
+function push(xs) {
+  return xs ? [...xs] : reducer(
+    () => [],
+    (acc, x) => (acc.push(x), acc)
+  );
 }
+export {
+  push
+};

package/range-nd.js

@@ -2,39 +2,10 @@ import { map } from "./map.js";
 import { permutations } from "./permutations.js";
 import { range, Range } from "./range.js";
 import { zip } from "./zip.js";
-/**
- * If called with one vector, yields an iterator for the n-dimensional
- * interval: `[[0, 0,...] .. [x, y,...])`. If called with two vectors,
- * the first vector defines the inclusive interval start and the 2nd
- * vector the exclusive interval end. Each dimension can also contain
- * negative values.
- *
- * @example
- * ```ts
- * [...rangeNd([2])]
- * // [ [ 0 ], [ 1 ] ]
- *
- * [...rangeNd([2, -2])]
- * // [ [ 0, 0 ], [ 0, -1 ], [ 1, 0 ], [ 1, -1 ] ]
- *
- * [...rangeNd([-1,2], [1,3])]
- * // [ [ -1, 2 ], [ -1, 3 ], [ 0, 2 ], [ 0, 3 ] ]
- *
- * [...rangeNd([2, 2, 2])]
- * // [
- * //   [ 0, 0, 0 ],
- * //   [ 0, 0, 1 ],
- * //   [ 0, 1, 0 ],
- * //   [ 0, 1, 1 ],
- * //   [ 1, 0, 0 ],
- * //   [ 1, 0, 1 ],
- * //   [ 1, 1, 0 ],
- * //   [ 1, 1, 1 ]
- * // ]
- * ```
- *
- * @param vec -
- */
-export const rangeNd = (min, max) => permutations.apply(null, ((max
-    ? [...map(([a, b]) => range(a, b), zip(min, max))]
-    : [...map(range, min)])));
+const rangeNd = (min, max) => permutations.apply(
+  null,
+  max ? [...map(([a, b]) => range(a, b), zip(min, max))] : [...map(range, min)]
+);
+export {
+  rangeNd
+};

package/range.js

@@ -1,57 +1,53 @@
 import { isReduced, Reduced } from "./reduced.js";
-export function range(from, to, step) {
-    return new Range(from, to, step);
+function range(from, to, step) {
+  return new Range(from, to, step);
 }
-/**
- * Simple class wrapper around given range interval and implementing `Iterable`
- * and {@link IReducible} interfaces, the latter is used to accelerate use with
- * {@link reduce}.
- */
-export class Range {
-    from;
-    to;
-    step;
-    constructor(from, to, step) {
-        if (from === undefined) {
-            from = 0;
-            to = Infinity;
-        }
-        else if (to === undefined) {
-            to = from;
-            from = 0;
-        }
-        step = step === undefined ? (from < to ? 1 : -1) : step;
-        this.from = from;
-        this.to = to;
-        this.step = step;
+class Range {
+  from;
+  to;
+  step;
+  constructor(from, to, step) {
+    if (from === void 0) {
+      from = 0;
+      to = Infinity;
+    } else if (to === void 0) {
+      to = from;
+      from = 0;
     }
-    *[Symbol.iterator]() {
-        let { from, to, step } = this;
-        if (step > 0) {
-            while (from < to) {
-                yield from;
-                from += step;
-            }
-        }
-        else if (step < 0) {
-            while (from > to) {
-                yield from;
-                from += step;
-            }
-        }
+    step = step === void 0 ? from < to ? 1 : -1 : step;
+    this.from = from;
+    this.to = to;
+    this.step = step;
+  }
+  *[Symbol.iterator]() {
+    let { from, to, step } = this;
+    if (step > 0) {
+      while (from < to) {
+        yield from;
+        from += step;
+      }
+    } else if (step < 0) {
+      while (from > to) {
+        yield from;
+        from += step;
+      }
     }
-    $reduce(rfn, acc) {
-        const step = this.step;
-        if (step > 0) {
-            for (let i = this.from, n = this.to; i < n && !isReduced(acc); i += step) {
-                acc = rfn(acc, i);
-            }
-        }
-        else {
-            for (let i = this.from, n = this.to; i > n && !isReduced(acc); i += step) {
-                acc = rfn(acc, i);
-            }
-        }
-        return acc;
+  }
+  $reduce(rfn, acc) {
+    const step = this.step;
+    if (step > 0) {
+      for (let i = this.from, n = this.to; i < n && !isReduced(acc); i += step) {
+        acc = rfn(acc, i);
+      }
+    } else {
+      for (let i = this.from, n = this.to; i > n && !isReduced(acc); i += step) {
+        acc = rfn(acc, i);
+      }
     }
+    return acc;
+  }
 }
+export {
+  Range,
+  range
+};

package/range2d.js

@@ -1,26 +1,29 @@
 import { illegalArity } from "@thi.ng/errors/illegal-arity";
 import { range } from "./range.js";
-export function* range2d(...args) {
-    let fromX, toX, stepX;
-    let fromY, toY, stepY;
-    switch (args.length) {
-        case 6:
-            stepX = args[4];
-            stepY = args[5];
-        case 4:
-            [fromX, toX, fromY, toY] = args;
-            break;
-        case 2:
-            [toX, toY] = args;
-            fromX = fromY = 0;
-            break;
-        default:
-            illegalArity(args.length);
-    }
-    const rx = range(fromX, toX, stepX);
-    for (let y of range(fromY, toY, stepY)) {
-        for (let x of rx) {
-            yield [x, y];
-        }
+function* range2d(...args) {
+  let fromX, toX, stepX;
+  let fromY, toY, stepY;
+  switch (args.length) {
+    case 6:
+      stepX = args[4];
+      stepY = args[5];
+    case 4:
+      [fromX, toX, fromY, toY] = args;
+      break;
+    case 2:
+      [toX, toY] = args;
+      fromX = fromY = 0;
+      break;
+    default:
+      illegalArity(args.length);
+  }
+  const rx = range(fromX, toX, stepX);
+  for (let y of range(fromY, toY, stepY)) {
+    for (let x of rx) {
+      yield [x, y];
     }
+  }
 }
+export {
+  range2d
+};

package/range3d.js

@@ -1,31 +1,34 @@
 import { illegalArity } from "@thi.ng/errors/illegal-arity";
 import { range } from "./range.js";
-export function* range3d(...args) {
-    let fromX, toX, stepX;
-    let fromY, toY, stepY;
-    let fromZ, toZ, stepZ;
-    switch (args.length) {
-        case 9:
-            stepX = args[6];
-            stepY = args[7];
-            stepZ = args[8];
-        case 6:
-            [fromX, toX, fromY, toY, fromZ, toZ] = args;
-            break;
-        case 3:
-            [toX, toY, toZ] = args;
-            fromX = fromY = fromZ = 0;
-            break;
-        default:
-            illegalArity(args.length);
-    }
-    const rx = range(fromX, toX, stepX);
-    const ry = range(fromY, toY, stepY);
-    for (let z of range(fromZ, toZ, stepZ)) {
-        for (let y of ry) {
-            for (let x of rx) {
-                yield [x, y, z];
-            }
-        }
+function* range3d(...args) {
+  let fromX, toX, stepX;
+  let fromY, toY, stepY;
+  let fromZ, toZ, stepZ;
+  switch (args.length) {
+    case 9:
+      stepX = args[6];
+      stepY = args[7];
+      stepZ = args[8];
+    case 6:
+      [fromX, toX, fromY, toY, fromZ, toZ] = args;
+      break;
+    case 3:
+      [toX, toY, toZ] = args;
+      fromX = fromY = fromZ = 0;
+      break;
+    default:
+      illegalArity(args.length);
+  }
+  const rx = range(fromX, toX, stepX);
+  const ry = range(fromY, toY, stepY);
+  for (let z of range(fromZ, toZ, stepZ)) {
+    for (let y of ry) {
+      for (let x of rx) {
+        yield [x, y, z];
+      }
     }
+  }
 }
+export {
+  range3d
+};

package/rechunk.js

@@ -1,34 +1,37 @@
 import { iterator, __iter } from "./iterator.js";
 import { isReduced } from "./reduced.js";
-export function rechunk(...args) {
-    const iter = __iter(rechunk, args, iterator);
-    if (iter)
-        return iter;
-    return ([init, complete, reduce]) => {
-        let buf = "";
-        const re = args[0] || /\r?\n/;
-        return [
-            init,
-            (acc) => {
-                if (buf)
-                    acc = reduce(acc, buf);
-                return complete(acc);
-            },
-            (acc, chunk) => {
-                buf += chunk;
-                const res = buf.split(re);
-                if (res.length > 1) {
-                    buf = res.pop();
-                    for (let l of res) {
-                        acc = reduce(acc, l);
-                        if (isReduced(acc)) {
-                            buf = "";
-                            break;
-                        }
-                    }
-                }
-                return acc;
-            },
-        ];
-    };
+function rechunk(...args) {
+  const iter = __iter(rechunk, args, iterator);
+  if (iter)
+    return iter;
+  return ([init, complete, reduce]) => {
+    let buf = "";
+    const re = args[0] || /\r?\n/;
+    return [
+      init,
+      (acc) => {
+        if (buf)
+          acc = reduce(acc, buf);
+        return complete(acc);
+      },
+      (acc, chunk) => {
+        buf += chunk;
+        const res = buf.split(re);
+        if (res.length > 1) {
+          buf = res.pop();
+          for (let l of res) {
+            acc = reduce(acc, l);
+            if (isReduced(acc)) {
+              buf = "";
+              break;
+            }
+          }
+        }
+        return acc;
+      }
+    ];
+  };
 }
+export {
+  rechunk
+};

package/reduce.js

@@ -3,76 +3,66 @@ import { isArrayLike } from "@thi.ng/checks/is-arraylike";
 import { isIterable } from "@thi.ng/checks/is-iterable";
 import { illegalArity } from "@thi.ng/errors/illegal-arity";
 import { isReduced, unreduced } from "./reduced.js";
-const parseArgs = (args) => args.length === 2
-    ? [undefined, args[1]]
-    : args.length === 3
-        ? [args[1], args[2]]
-        : illegalArity(args.length);
-export function reduce(...args) {
-    const rfn = args[0];
-    const init = rfn[0];
-    const complete = rfn[1];
-    const reduce = rfn[2];
-    args = parseArgs(args);
-    const acc = args[0] == null ? init() : args[0];
-    const xs = args[1];
-    return unreduced(complete(implementsFunction(xs, "$reduce")
-        ? xs.$reduce(reduce, acc)
-        : isArrayLike(xs)
-            ? reduceArray(reduce, acc, xs)
-            : reduceIterable(reduce, acc, xs)));
+const parseArgs = (args) => args.length === 2 ? [void 0, args[1]] : args.length === 3 ? [args[1], args[2]] : illegalArity(args.length);
+function reduce(...args) {
+  const rfn = args[0];
+  const init = rfn[0];
+  const complete = rfn[1];
+  const reduce2 = rfn[2];
+  args = parseArgs(args);
+  const acc = args[0] == null ? init() : args[0];
+  const xs = args[1];
+  return unreduced(
+    complete(
+      implementsFunction(xs, "$reduce") ? xs.$reduce(reduce2, acc) : isArrayLike(xs) ? reduceArray(reduce2, acc, xs) : reduceIterable(reduce2, acc, xs)
+    )
+  );
 }
-export function reduceRight(...args) {
-    const rfn = args[0];
-    const init = rfn[0];
-    const complete = rfn[1];
-    const reduce = rfn[2];
-    args = parseArgs(args);
-    let acc = args[0] == null ? init() : args[0];
-    const xs = args[1];
-    for (let i = xs.length; i-- > 0;) {
-        acc = reduce(acc, xs[i]);
-        if (isReduced(acc)) {
-            acc = acc.deref();
-            break;
-        }
+function reduceRight(...args) {
+  const rfn = args[0];
+  const init = rfn[0];
+  const complete = rfn[1];
+  const reduce2 = rfn[2];
+  args = parseArgs(args);
+  let acc = args[0] == null ? init() : args[0];
+  const xs = args[1];
+  for (let i = xs.length; i-- > 0; ) {
+    acc = reduce2(acc, xs[i]);
+    if (isReduced(acc)) {
+      acc = acc.deref();
+      break;
     }
-    return unreduced(complete(acc));
+  }
+  return unreduced(complete(acc));
 }
 const reduceArray = (rfn, acc, xs) => {
-    for (let i = 0, n = xs.length; i < n; i++) {
-        acc = rfn(acc, xs[i]);
-        if (isReduced(acc)) {
-            acc = acc.deref();
-            break;
-        }
+  for (let i = 0, n = xs.length; i < n; i++) {
+    acc = rfn(acc, xs[i]);
+    if (isReduced(acc)) {
+      acc = acc.deref();
+      break;
     }
-    return acc;
+  }
+  return acc;
 };
 const reduceIterable = (rfn, acc, xs) => {
-    for (let x of xs) {
-        acc = rfn(acc, x);
-        if (isReduced(acc)) {
-            acc = acc.deref();
-            break;
-        }
+  for (let x of xs) {
+    acc = rfn(acc, x);
+    if (isReduced(acc)) {
+      acc = acc.deref();
+      break;
     }
-    return acc;
+  }
+  return acc;
 };
-/**
- * Convenience helper for building a full {@link Reducer} using the identity
- * function (i.e. `(x) => x`) as completion step (true for 90% of all
- * bundled transducers).
- *
- * @param init - init step of reducer
- * @param rfn - reduction step of reducer
- */
-export const reducer = (init, rfn) => [init, (acc) => acc, rfn];
-export const $$reduce = (rfn, args) => {
-    const n = args.length - 1;
-    return isIterable(args[n])
-        ? args.length > 1
-            ? reduce(rfn.apply(null, args.slice(0, n)), args[n])
-            : reduce(rfn(), args[0])
-        : undefined;
+const reducer = (init, rfn) => [init, (acc) => acc, rfn];
+const $$reduce = (rfn, args) => {
+  const n = args.length - 1;
+  return isIterable(args[n]) ? args.length > 1 ? reduce(rfn.apply(null, args.slice(0, n)), args[n]) : reduce(rfn(), args[0]) : void 0;
+};
+export {
+  $$reduce,
+  reduce,
+  reduceRight,
+  reducer
 };

package/reduced.js

@@ -1,13 +1,20 @@
-export class Reduced {
-    value;
-    constructor(val) {
-        this.value = val;
-    }
-    deref() {
-        return this.value;
-    }
+class Reduced {
+  value;
+  constructor(val) {
+    this.value = val;
+  }
+  deref() {
+    return this.value;
+  }
 }
-export const reduced = (x) => new Reduced(x);
-export const isReduced = (x) => x instanceof Reduced;
-export const ensureReduced = (x) => x instanceof Reduced ? x : new Reduced(x);
-export const unreduced = (x) => (x instanceof Reduced ? x.deref() : x);
+const reduced = (x) => new Reduced(x);
+const isReduced = (x) => x instanceof Reduced;
+const ensureReduced = (x) => x instanceof Reduced ? x : new Reduced(x);
+const unreduced = (x) => x instanceof Reduced ? x.deref() : x;
+export {
+  Reduced,
+  ensureReduced,
+  isReduced,
+  reduced,
+  unreduced
+};