@thi.ng/transducers 8.8.13 → 8.8.15

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2023-12-03T12:13:31Z
+- **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/add.js

@@ -1,4 +1,7 @@
 import { __mathop } from "./internal/mathop.js";
-export function add(...args) {
-    return __mathop(add, (acc, x) => acc + x, 0, args);
+function add(...args) {
+  return __mathop(add, (acc, x) => acc + x, 0, args);
 }
+export {
+  add
+};

package/api.js

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

package/as-iterable.js

@@ -1,9 +1,6 @@
-/**
- * Helper function / generator to (re)provide given iterable in iterator
- * form.
- *
- * @param src -
- */
-export function* asIterable(src) {
-    yield* src;
+function* asIterable(src) {
+  yield* src;
 }
+export {
+  asIterable
+};

package/assoc-map.js

@@ -1,6 +1,10 @@
 import { reduce, reducer } from "./reduce.js";
-export function assocMap(xs) {
-    return xs
-        ? reduce(assocMap(), xs)
-        : reducer(() => new Map(), (acc, [k, v]) => acc.set(k, v));
+function assocMap(xs) {
+  return xs ? reduce(assocMap(), xs) : reducer(
+    () => /* @__PURE__ */ new Map(),
+    (acc, [k, v]) => acc.set(k, v)
+  );
 }
+export {
+  assocMap
+};

package/assoc-obj.js

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

package/auto-obj.js

@@ -1,7 +1,11 @@
 import { reduce, reducer } from "./reduce.js";
-export function autoObj(prefix, xs) {
-    let id = 0;
-    return xs
-        ? reduce(autoObj(prefix), xs)
-        : reducer(() => ({}), (acc, v) => ((acc[prefix + id++] = v), acc));
+function autoObj(prefix, xs) {
+  let id = 0;
+  return xs ? reduce(autoObj(prefix), xs) : reducer(
+    () => ({}),
+    (acc, v) => (acc[prefix + id++] = v, acc)
+  );
 }
+export {
+  autoObj
+};

package/benchmark.js

@@ -1,17 +1,18 @@
 import { isIterable } from "@thi.ng/checks/is-iterable";
 import { compR } from "./compr.js";
 import { iterator1 } from "./iterator.js";
-export function benchmark(src) {
-    return isIterable(src)
-        ? iterator1(benchmark(), src)
-        : (rfn) => {
-            const r = rfn[2];
-            let prev = Date.now();
-            return compR(rfn, (acc, _) => {
-                const t = Date.now();
-                const x = t - prev;
-                prev = t;
-                return r(acc, x);
-            });
-        };
+function benchmark(src) {
+  return isIterable(src) ? iterator1(benchmark(), src) : (rfn) => {
+    const r = rfn[2];
+    let prev = Date.now();
+    return compR(rfn, (acc, _) => {
+      const t = Date.now();
+      const x = t - prev;
+      prev = t;
+      return r(acc, x);
+    });
+  };
 }
+export {
+  benchmark
+};

package/cat.js

@@ -1,53 +1,19 @@
 import { compR } from "./compr.js";
 import { ensureReduced, isReduced, unreduced } from "./reduced.js";
-/**
- * Transducer to concatenate iterable values. Iterates over each input and emits
- * individual values down stream, therefore removing one level of nesting from
- * the input.
- *
- * @remarks
- * If, during processing, the transducer is given a wrapped reduced input
- * iterable, it will still be processed as normal, but then immediately triggers
- * early termination by wrapping its own result in {@link reduced}. E.g. this
- * behavior allows a {@link mapcat} user functions to benefit from reduced
- * results.
- *
- * Also see:
- * - {@link concat}
- * - {@link mapcat}
- *
- * @example
- * ```ts
- * [...iterator(comp(map((x) => [x, x]), cat()), [1, 2, 3, 4])]
- * // [ 1, 1, 2, 2, 3, 3, 4, 4 ]
- *
- * [...iterator(
- *   comp(
- *     mapIndexed((i, x) => [[i], [x, x]]),
- *     cat(),
- *     cat()
- *   ),
- *   "abc"
- * )]
- * // [ 0, 'a', 'a', 1, 'b', 'b', 2, 'c', 'c' ]
- *
- * [...mapcat((x)=>(x > 1 ? reduced([x, x]) : [x, x]), [1, 2, 3, 4])]
- * // [ 1, 1, 2, 2 ]
- * ```
- *
- * @param rfn -
- */
-export const cat = () => (rfn) => {
-    const r = rfn[2];
-    return compR(rfn, (acc, x) => {
-        if (x) {
-            for (let y of unreduced(x)) {
-                acc = r(acc, y);
-                if (isReduced(acc)) {
-                    break;
-                }
-            }
+const cat = () => (rfn) => {
+  const r = rfn[2];
+  return compR(rfn, (acc, x) => {
+    if (x) {
+      for (let y of unreduced(x)) {
+        acc = r(acc, y);
+        if (isReduced(acc)) {
+          break;
         }
-        return isReduced(x) ? ensureReduced(acc) : acc;
-    });
+      }
+    }
+    return isReduced(x) ? ensureReduced(acc) : acc;
+  });
+};
+export {
+  cat
 };

package/choices.js

@@ -2,22 +2,9 @@ import { ensureArray } from "@thi.ng/arrays/ensure-array";
 import { SYSTEM } from "@thi.ng/random/system";
 import { weightedRandom } from "@thi.ng/random/weighted-random";
 import { repeatedly } from "./repeatedly.js";
-/**
- * Returns an infinite iterator of random choices and their (optional) weights.
- * If `weights` is given, it must have at least the same size as `choices`. If
- * omitted, each choice will have same probability.
- *
- * @example
- * ```ts
- * transduce(take(1000), frequencies(), choices("abcd", [1, 0.5, 0.25, 0.125]))
- * // Map { 'c' => 132, 'a' => 545, 'b' => 251, 'd' => 72 }
- * ```
- *
- * [`weightedRandom()`](https://docs.thi.ng/umbrella/random/functions/weightedRandom.html)
- *
- * @param choices -
- * @param weights -
- */
-export const choices = (choices, weights, rnd = SYSTEM) => repeatedly(weights
-    ? weightedRandom(ensureArray(choices), weights, rnd)
-    : () => choices[rnd.float(choices.length) | 0]);
+const choices = (choices2, weights, rnd = SYSTEM) => repeatedly(
+  weights ? weightedRandom(ensureArray(choices2), weights, rnd) : () => choices2[rnd.float(choices2.length) | 0]
+);
+export {
+  choices
+};

package/comp.js

@@ -1,6 +1,9 @@
 import { comp as _comp } from "@thi.ng/compose/comp";
 import { ensureTransducer } from "./ensure.js";
-export function comp(...fns) {
-    fns = fns.map(ensureTransducer);
-    return _comp.apply(null, fns);
+function comp(...fns) {
+  fns = fns.map(ensureTransducer);
+  return _comp.apply(null, fns);
 }
+export {
+  comp
+};

package/compr.js

@@ -1,25 +1,4 @@
-/**
- * Reducer composition helper, internally used by various transducers
- * during initialization. Takes existing reducer `rfn` (a 3-tuple) and a
- * reducing function `fn`. Returns a new reducer tuple.
- *
- * @remarks
- * `rfn[2]` reduces values of type `B` into an accumulator of type `A`.
- * `fn` accepts values of type `C` and produces interim results of type
- * `B`, which are then (possibly) passed to the "inner" `rfn[2]`
- * function. Therefore the resulting reducer takes inputs of `C` and an
- * accumulator of type `A`.
- *
- * It is assumed that `fn` internally calls `rfn[2]` to pass its own
- * results for further processing by the nested reducer `rfn`.
- *
- * @example
- * ```ts
- * compR(rfn, fn)
- * // [rfn[0], rfn[1], fn]
- * ```
- *
- * @param rfn -
- * @param fn -
- */
-export const compR = (rfn, fn) => [rfn[0], rfn[1], fn];
+const compR = (rfn, fn) => [rfn[0], rfn[1], fn];
+export {
+  compR
+};

package/concat.js

@@ -1,22 +1,9 @@
 import { ensureIterable } from "@thi.ng/arrays/ensure-iterable";
-/**
- * Yields iterator producing concatenation of given iterables.
- * Undefined & null inputs are silently ignored, however any
- * such values produced or contained in an input will remain.
- *
- * @example
- * ```ts
- * [...concat([1, 2, 3], null, [4, 5])]
- * // [ 1, 2, 3, 4, 5 ]
- *
- * [...concat([1, 2, 3, undefined], null, [4, 5])]
- * // [ 1, 2, 3, undefined, 4, 5 ]
- * ```
- *
- * @param xs -
- */
-export function* concat(...xs) {
-    for (let x of xs) {
-        x != null && (yield* ensureIterable(x));
-    }
+function* concat(...xs) {
+  for (let x of xs) {
+    x != null && (yield* ensureIterable(x));
+  }
 }
+export {
+  concat
+};

package/conj.js

@@ -1,6 +1,10 @@
 import { reduce, reducer } from "./reduce.js";
-export function conj(xs) {
-    return xs
-        ? reduce(conj(), xs)
-        : reducer(() => new Set(), (acc, x) => acc.add(x));
+function conj(xs) {
+  return xs ? reduce(conj(), xs) : reducer(
+    () => /* @__PURE__ */ new Set(),
+    (acc, x) => acc.add(x)
+  );
 }
+export {
+  conj
+};

package/consume.js

@@ -1,25 +1,7 @@
-/**
- * Consumes given iterable, presumably for any implicit side-effects. Iterable
- * MUST be finite!
- *
- * @remarks
- * See {@link run} for a similar approach when also side-effecting transducers
- * should be applied.
- *
- * @example
- * ```ts
- * consume(repeatedly2d((x, y) => console.log("output:", [x, y]), 2, 3));
- * // output: [ 0, 0 ]
- * // output: [ 1, 0 ]
- * // output: [ 0, 1 ]
- * // output: [ 1, 1 ]
- * // output: [ 0, 2 ]
- * // output: [ 1, 2 ]
- * ```
- *
- * @param src
- */
-export const consume = (src) => {
-    for (let _ of src)
-        ;
+const consume = (src) => {
+  for (let _ of src)
+    ;
+};
+export {
+  consume
 };

package/converge.js

@@ -2,20 +2,22 @@ import { SEMAPHORE } from "@thi.ng/api/api";
 import { compR } from "./compr.js";
 import { __iter } from "./iterator.js";
 import { ensureReduced } from "./reduced.js";
-export function converge(...args) {
-    return (__iter(converge, args) ||
-        ((rfn) => {
-            const r = rfn[2];
-            const pred = args[0];
-            let prev = SEMAPHORE;
-            let done = false;
-            return compR(rfn, (acc, x) => {
-                if (done || (prev !== SEMAPHORE && pred(prev, x))) {
-                    done = true;
-                    return ensureReduced(r(acc, x));
-                }
-                prev = x;
-                return r(acc, x);
-            });
-        }));
+function converge(...args) {
+  return __iter(converge, args) || ((rfn) => {
+    const r = rfn[2];
+    const pred = args[0];
+    let prev = SEMAPHORE;
+    let done = false;
+    return compR(rfn, (acc, x) => {
+      if (done || prev !== SEMAPHORE && pred(prev, x)) {
+        done = true;
+        return ensureReduced(r(acc, x));
+      }
+      prev = x;
+      return r(acc, x);
+    });
+  });
 }
+export {
+  converge
+};

package/convolve.js

@@ -6,62 +6,74 @@ import { range } from "./range.js";
 import { range2d } from "./range2d.js";
 import { transduce } from "./transduce.js";
 import { zip } from "./zip.js";
-export const buildKernel1d = (weights, w) => {
-    const w2 = w >> 1;
-    return [...zip(weights, range(-w2, w2 + 1))];
+const buildKernel1d = (weights, w) => {
+  const w2 = w >> 1;
+  return [...zip(weights, range(-w2, w2 + 1))];
 };
-export const buildKernel2d = (weights, w, h = w) => {
-    const w2 = w >> 1;
-    const h2 = h >> 1;
-    return [...zip(weights, range2d(-w2, w2 + 1, -h2, h2 + 1))];
+const buildKernel2d = (weights, w, h = w) => {
+  const w2 = w >> 1;
+  const h2 = h >> 1;
+  return [...zip(weights, range2d(-w2, w2 + 1, -h2, h2 + 1))];
+};
+const kernelLookup1d = (src, x, width, wrap, border) => wrap ? ({ 0: w, 1: ox }) => {
+  const xx = x < -ox ? width + ox : x >= width - ox ? ox - 1 : x + ox;
+  return w * src[xx];
+} : ({ 0: w, 1: ox }) => {
+  return x < -ox || x >= width - ox ? border : w * src[x + ox];
+};
+const kernelLookup2d = (src, x, y, width, height, wrap, border) => wrap ? ({ 0: w, 1: { 0: ox, 1: oy } }) => {
+  const xx = x < -ox ? width + ox : x >= width - ox ? ox - 1 : x + ox;
+  const yy = y < -oy ? height + oy : y >= height - oy ? oy - 1 : y + oy;
+  return w * src[yy * width + xx];
+} : ({ 0: w, 1: { 0: ox, 1: oy } }) => {
+  return x < -ox || y < -oy || x >= width - ox || y >= height - oy ? border : w * src[(y + oy) * width + x + ox];
 };
-const kernelLookup1d = (src, x, width, wrap, border) => wrap
-    ? ({ 0: w, 1: ox }) => {
-        const xx = x < -ox ? width + ox : x >= width - ox ? ox - 1 : x + ox;
-        return w * src[xx];
-    }
-    : ({ 0: w, 1: ox }) => {
-        return x < -ox || x >= width - ox ? border : w * src[x + ox];
-    };
-const kernelLookup2d = (src, x, y, width, height, wrap, border) => wrap
-    ? ({ 0: w, 1: { 0: ox, 1: oy } }) => {
-        const xx = x < -ox ? width + ox : x >= width - ox ? ox - 1 : x + ox;
-        const yy = y < -oy ? height + oy : y >= height - oy ? oy - 1 : y + oy;
-        return w * src[yy * width + xx];
-    }
-    : ({ 0: w, 1: { 0: ox, 1: oy } }) => {
-        return x < -ox || y < -oy || x >= width - ox || y >= height - oy
-            ? border
-            : w * src[(y + oy) * width + x + ox];
-    };
 const kernelError = () => illegalArgs(`no kernel or kernel config`);
-export function convolve1d(opts, indices) {
-    if (indices) {
-        return iterator1(convolve1d(opts), indices);
-    }
-    const { src, width } = opts;
-    const wrap = opts.wrap !== false;
-    const border = opts.border || 0;
-    const rfn = opts.reduce || add;
-    let kernel = opts.kernel;
-    if (!kernel) {
-        !(opts.weights && opts.kwidth) && kernelError();
-        kernel = buildKernel1d(opts.weights, opts.kwidth);
-    }
-    return map((p) => transduce(map(kernelLookup1d(src, p, width, wrap, border)), rfn(), kernel));
+function convolve1d(opts, indices) {
+  if (indices) {
+    return iterator1(convolve1d(opts), indices);
+  }
+  const { src, width } = opts;
+  const wrap = opts.wrap !== false;
+  const border = opts.border || 0;
+  const rfn = opts.reduce || add;
+  let kernel = opts.kernel;
+  if (!kernel) {
+    !(opts.weights && opts.kwidth) && kernelError();
+    kernel = buildKernel1d(opts.weights, opts.kwidth);
+  }
+  return map(
+    (p) => transduce(
+      map(kernelLookup1d(src, p, width, wrap, border)),
+      rfn(),
+      kernel
+    )
+  );
 }
-export function convolve2d(opts, indices) {
-    if (indices) {
-        return iterator1(convolve2d(opts), indices);
-    }
-    const { src, width, height } = opts;
-    const wrap = opts.wrap !== false;
-    const border = opts.border || 0;
-    const rfn = opts.reduce || add;
-    let kernel = opts.kernel;
-    if (!kernel) {
-        !(opts.weights && opts.kwidth && opts.kheight) && kernelError();
-        kernel = buildKernel2d(opts.weights, opts.kwidth, opts.kheight);
-    }
-    return map((p) => transduce(map(kernelLookup2d(src, p[0], p[1], width, height, wrap, border)), rfn(), kernel));
+function convolve2d(opts, indices) {
+  if (indices) {
+    return iterator1(convolve2d(opts), indices);
+  }
+  const { src, width, height } = opts;
+  const wrap = opts.wrap !== false;
+  const border = opts.border || 0;
+  const rfn = opts.reduce || add;
+  let kernel = opts.kernel;
+  if (!kernel) {
+    !(opts.weights && opts.kwidth && opts.kheight) && kernelError();
+    kernel = buildKernel2d(opts.weights, opts.kwidth, opts.kheight);
+  }
+  return map(
+    (p) => transduce(
+      map(kernelLookup2d(src, p[0], p[1], width, height, wrap, border)),
+      rfn(),
+      kernel
+    )
+  );
 }
+export {
+  buildKernel1d,
+  buildKernel2d,
+  convolve1d,
+  convolve2d
+};

package/count.js

@@ -1,10 +1,16 @@
 import { $$reduce, reducer } from "./reduce.js";
-export function count(...args) {
-    const res = $$reduce(count, args);
-    if (res !== undefined) {
-        return res;
-    }
-    let offset = args[0] || 0;
-    let step = args[1] || 1;
-    return reducer(() => offset, (acc, _) => acc + step);
+function count(...args) {
+  const res = $$reduce(count, args);
+  if (res !== void 0) {
+    return res;
+  }
+  let offset = args[0] || 0;
+  let step = args[1] || 1;
+  return reducer(
+    () => offset,
+    (acc, _) => acc + step
+  );
 }
+export {
+  count
+};

package/curve.js

@@ -1,46 +1,13 @@
-/**
- * Iterator producing an exponential curve (with adjustable curvature) between
- * `start` and `end` values over `num` steps. This is the exponential equivalent
- * of {@link line}.
- *
- * @remarks
- * Since `start` is the first value emitted, the `end` value is only reached in
- * the `num+1`th step.
- *
- * The curvature can be controlled via the logarithmic `rate` param. Recommended
- * range [0.0001 - 10000] (curved -> linear). Default: 0.1
- *
- * Similar functionality (w/ more options) is availble here:
- * [`curve()`](https://docs.thi.ng/umbrella/dsp/functions/curve.html).
- *
- * @example
- * ```ts
- * [...curve(50, 100, 10, 2)]
- * // [
- * //   50,
- * //   73.193,
- * //   85.649,
- * //   92.339,
- * //   95.932,
- * //   97.861,
- * //   98.897,
- * //   99.454,
- * //   99.753,
- * //   99.913,
- * //   100
- * // ]
- * ```
- *
- * @param start -
- * @param end -
- * @param steps -
- * @param falloff -
- */
-export function* curve(start, end, steps = 10, rate = 0.1) {
-    const c = Math.exp(-Math.log((Math.abs(end - start) + rate) / rate) / steps);
-    const offset = (start < end ? end + rate : end - rate) * (1 - c);
-    steps > 0 && (yield start);
-    for (let x = start; steps-- > 0;) {
-        yield (x = offset + x * c);
-    }
+function* curve(start, end, steps = 10, rate = 0.1) {
+  const c = Math.exp(
+    -Math.log((Math.abs(end - start) + rate) / rate) / steps
+  );
+  const offset = (start < end ? end + rate : end - rate) * (1 - c);
+  steps > 0 && (yield start);
+  for (let x = start; steps-- > 0; ) {
+    yield x = offset + x * c;
+  }
 }
+export {
+  curve
+};

package/cycle.js

@@ -1,36 +1,17 @@
-/**
- * Iterator which yields an infinite repetition of given `input`
- * iterable's values. Produces no values if `input` is empty. If `num`
- * is given, only that many cycles will be emitted.
- *
- * @remarks
- * Also see {@link repeat}, {@link repeatedly} for related functions.
- *
- * @example
- * ```ts
- * // take 5 from infinite sequence
- * [...take(5, cycle([1, 2, 3]))]
- * // [1, 2, 3, 1, 2]
- *
- * // only produce 2 cycles
- * [...cycle(range(3), 2)]
- * // [ 0, 1, 2, 0, 1, 2 ]
- * ```
- *
- * @param input -
- * @param num -
- */
-export function* cycle(input, num = Infinity) {
-    if (num < 1)
-        return;
-    let cache = [];
-    for (let i of input) {
-        cache.push(i);
-        yield i;
-    }
-    if (cache.length > 0) {
-        while (--num > 0) {
-            yield* cache;
-        }
+function* cycle(input, num = Infinity) {
+  if (num < 1)
+    return;
+  let cache = [];
+  for (let i of input) {
+    cache.push(i);
+    yield i;
+  }
+  if (cache.length > 0) {
+    while (--num > 0) {
+      yield* cache;
     }
+  }
 }
+export {
+  cycle
+};