@thi.ng/transducers 9.0.4 → 9.0.6

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-04-25T19:44:55Z
+- **Last updated**: 2024-06-21T19:34:38Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,14 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+### [9.0.6](https://github.com/thi-ng/umbrella/tree/@thi.ng/transducers@9.0.6) (2024-06-21)
+
+#### ♻️ Refactoring
+
+- rename various rest args to be more semantically meaningful ([8088a56](https://github.com/thi-ng/umbrella/commit/8088a56))
+- enforce uniform naming convention of internal functions ([56992b2](https://github.com/thi-ng/umbrella/commit/56992b2))
+- dedupe min/maxCompare() impls, add tests ([22fc6e3](https://github.com/thi-ng/umbrella/commit/22fc6e3))
+
 ### [9.0.2](https://github.com/thi-ng/umbrella/tree/@thi.ng/transducers@9.0.2) (2024-04-20)
 
 #### ♻️ Refactoring

package/README.md

@@ -7,7 +7,7 @@
 [![Mastodon Follow](https://img.shields.io/mastodon/follow/109331703950160316?domain=https%3A%2F%2Fmastodon.thi.ng&style=social)](https://mastodon.thi.ng/@toxi)
 
 > [!NOTE]
-> This is one of 192 standalone projects, maintained as part
+> This is one of 193 standalone projects, maintained as part
 > of the [@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo
 > and anti-framework.
 >
@@ -151,7 +151,7 @@ For Node.js REPL:
 const tx = await import("@thi.ng/transducers");
 ```
 
-Package sizes (brotli'd, pre-treeshake): ESM: 8.89 KB
+Package sizes (brotli'd, pre-treeshake): ESM: 8.95 KB
 
 ## Dependencies
 
@@ -185,6 +185,9 @@ directory are using this package:
 | <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/ellipse-proximity.png" width="240"/>             | Interactive visualization of closest points on ellipses                                                 | [Demo](https://demo.thi.ng/umbrella/ellipse-proximity/)    | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/ellipse-proximity)    |
 | <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/fft-synth.png" width="240"/>                     | Interactive inverse FFT toy synth                                                                       | [Demo](https://demo.thi.ng/umbrella/fft-synth/)            | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/fft-synth)            |
 | <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/fiber-basics.png" width="240"/>                  | Fiber-based cooperative multitasking basics                                                             | [Demo](https://demo.thi.ng/umbrella/fiber-basics/)         | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/fiber-basics)         |
+| <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/geom-complex-poly.png" width="240"/>             | Shape conversions & operations using polygons with holes                                                | [Demo](https://demo.thi.ng/umbrella/geom-complex-poly/)    | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/geom-complex-poly)    |
+| <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/geom-csv-piechart.png" width="240"/>             | Piechart visualization of CSV data                                                                      | [Demo](https://demo.thi.ng/umbrella/geom-csv-piechart/)    | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/geom-csv-piechart)    |
+| <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/geom-hexgrid.png" width="240"/>                  | Hex grid generation & tessellations                                                                     | [Demo](https://demo.thi.ng/umbrella/geom-hexgrid/)         | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/geom-hexgrid)         |
 | <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/grid-iterators.png" width="240"/>                | Visualization of different grid iterator strategies                                                     | [Demo](https://demo.thi.ng/umbrella/grid-iterators/)       | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/grid-iterators)       |
 | <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/hdom-benchmark2.png" width="240"/>               | hdom update performance benchmark w/ config options                                                     | [Demo](https://demo.thi.ng/umbrella/hdom-benchmark2/)      | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/hdom-benchmark2)      |
 | <img src="https://raw.githubusercontent.com/thi-ng/umbrella/develop/assets/examples/hdom-canvas-clock.png" width="240"/>             | Realtime analog clock demo                                                                              | [Demo](https://demo.thi.ng/umbrella/hdom-canvas-clock/)    | [Source](https://github.com/thi-ng/umbrella/tree/develop/examples/hdom-canvas-clock)    |

package/add.d.ts

@@ -3,6 +3,6 @@ import type { Reducer } from "./api.js";
  * Reducer to compute sum of values with given `init` value. Default: 0
  */
 export declare function add(init?: number): Reducer<number, number>;
-export declare function add(xs: Iterable<number>): number;
-export declare function add(init: number, xs: Iterable<number>): number;
+export declare function add(src: Iterable<number>): number;
+export declare function add(init: number, src: Iterable<number>): number;
 //# sourceMappingURL=add.d.ts.map

package/add.js

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

package/api.d.ts

@@ -30,6 +30,7 @@ export type ReductionFn<A, B> = (acc: B, x: A) => B | Reduced<B>;
  *    existing (partially) reduced result.
  */
 export type Reducer<A, B> = [Fn0<B>, Fn<B, B>, ReductionFn<A, B>];
+export type MaybeReduced<T> = Reduced<T> | T;
 /**
  * Interface for types able to provide some internal functionality (or
  * derive some related transformation) as {@link Transducer}.
@@ -37,23 +38,25 @@ export type Reducer<A, B> = [Fn0<B>, Fn<B, B>, ReductionFn<A, B>];
  * functions in this package where a `Transducer` arg is expected.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/ixform.ts
  * import {
- *   comp, drop, map, push, range, transduce
+ *   comp, drop, map, push, range, takeNth, transduce,
  *   type IXform
  * } from "@thi.ng/transducers";
  *
  * class Mul implements IXform<number, number> {
  *   constructor(public factor = 10) {}
  *
- *   xform() { return map((x) => this.factor * x); }
+ *   xform() { return map((x: number) => this.factor * x); }
  * }
  *
- * transduce(new Mul(11), push(), range(4))
+ * console.log(
+ *   transduce(new Mul(11), push(), range(4))
+ * );
  * // [0, 11, 22, 33, 44]
  *
  * // also usable w/ comp()
- * transduce(
+ * const res = transduce(
  *   comp(
  *     drop(1),
  *     new Mul(11),
@@ -61,7 +64,9 @@ export type Reducer<A, B> = [Fn0<B>, Fn<B, B>, ReductionFn<A, B>];
  *   ),
  *   push(),
  *   range(4)
- * )
+ * );
+ *
+ * console.log(res);
  * // [11, 33]
  * ```
  */

package/assoc-map.d.ts

@@ -2,8 +2,8 @@ import type { Pair } from "@thi.ng/api";
 import type { Reducer } from "./api.js";
 /**
  * Reducer accepting key-value pairs / tuples and transforming / adding
- * them to an ES6 Map.
+ * them to an ES6 Map. Also see {@link assocObj}.
  */
 export declare function assocMap<A, B>(): Reducer<Pair<A, B>, Map<A, B>>;
-export declare function assocMap<A, B>(xs: Iterable<Pair<A, B>>): Map<A, B>;
+export declare function assocMap<A, B>(src: Iterable<Pair<A, B>>): Map<A, B>;
 //# sourceMappingURL=assoc-map.d.ts.map

package/assoc-map.js

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

package/assoc-obj.d.ts

@@ -2,8 +2,8 @@ import type { IObjectOf, Pair } from "@thi.ng/api";
 import type { Reducer } from "./api.js";
 /**
  * Reducer accepting key-value pairs / tuples and updating / adding them
- * to an object.
+ * to an object. Also see {@link assocMap}.
  */
 export declare function assocObj<T>(): Reducer<Pair<PropertyKey, T>, IObjectOf<T>>;
-export declare function assocObj<T>(xs: Iterable<Pair<PropertyKey, T>>): IObjectOf<T>;
+export declare function assocObj<T>(src: Iterable<Pair<PropertyKey, T>>): IObjectOf<T>;
 //# sourceMappingURL=assoc-obj.d.ts.map

package/assoc-obj.js

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

package/auto-obj.d.ts

@@ -5,15 +5,17 @@ import type { Reducer } from "./api.js";
  * in an object. Keys consist of given `prefix` and monotonically increasing ID.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/auto-obj.ts
  * import { autoObj } from "@thi.ng/transducers";
  *
- * autoObj("id", ["foo", "bar", "baz"])
+ * console.log(
+ *   autoObj("id", ["foo", "bar", "baz"])
+ * );
  * // { id0: "foo", id1: "bar", id2: "baz" }
  * ```
  *
  * @param prefix - shared prefix
  */
 export declare function autoObj<T>(prefix: string): Reducer<T, IObjectOf<T>>;
-export declare function autoObj<T>(prefix: string, xs: Iterable<T>): IObjectOf<T>;
+export declare function autoObj<T>(prefix: string, src: Iterable<T>): IObjectOf<T>;
 //# sourceMappingURL=auto-obj.d.ts.map

package/auto-obj.js

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

package/benchmark.d.ts

@@ -5,13 +5,19 @@ import type { Transducer } from "./api.js";
  * e.g. for use in async usage contexts.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/benchmark.ts
  * import { fromInterval, trace } from "@thi.ng/rstream";
+ * import { benchmark, comp, movingAverage } from "@thi.ng/transducers";
  *
- * fromInterval(1000).subscribe(
+ * fromInterval(16).subscribe(
  *   trace(),
  *   { xform: comp(benchmark(), movingAverage(60)) }
- * )
+ * );
+ * // 16.766666666666666
+ * // 17.05
+ * // 17.033333333333335
+ * // 17.033333333333335
+ * // ...
  * ```
  */
 export declare function benchmark(): Transducer<any, number>;

package/cat.d.ts

@@ -1,5 +1,5 @@
 import type { Nullable } from "@thi.ng/api";
-import type { Transducer } from "./api.js";
+import type { MaybeReduced, Transducer } from "./api.js";
 /**
  * Transducer to concatenate iterable values. Iterates over each input and emits
  * individual values down stream, therefore removing one level of nesting from
@@ -15,29 +15,35 @@ import type { Transducer } from "./api.js";
  * Also see {@link concat}, {@link mapcat}.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/cat.ts
  * import {
  *   cat, comp, iterator, map, mapcat, mapIndexed, reduced
  * } from "@thi.ng/transducers";
  *
- * [...iterator(comp(map((x) => [x, x]), cat()), [1, 2, 3, 4])]
+ * console.log(
+ *   [...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"
- * )]
+ * console.log(
+ *   [...iterator(
+ *     comp(
+ *       mapIndexed((i, x) => [[i], [x, x]]),
+ *       cat<(number | string)[]>(),
+ *       cat()
+ *     ),
+ *     "abc"
+ *   )]
+ * );
  * // [ 0, 'a', 'a', 1, 'b', 'b', 2, 'c', 'c' ]
  *
- * [...mapcat((x)=>(x > 1 ? reduced([x, x]) : [x, x]), [1, 2, 3, 4])]
+ * console.log(
+ *   [...mapcat((x)=>(x > 1 ? reduced([x, x]) : [x, x]), [1, 2, 3, 4])]
+ * );
  * // [ 1, 1, 2, 2 ]
  * ```
  *
  * @param rfn -
  */
-export declare const cat: <T>() => Transducer<Nullable<Iterable<T>>, T>;
+export declare const cat: <T>() => Transducer<MaybeReduced<Nullable<Iterable<T>>>, T>;
 //# sourceMappingURL=cat.d.ts.map

package/cat.js

@@ -4,7 +4,7 @@ const cat = () => (rfn) => {
   const r = rfn[2];
   return compR(rfn, (acc, x) => {
     if (x) {
-      for (let y of unreduced(x)) {
+      for (let y of unreduced(x) || []) {
         acc = r(acc, y);
         if (isReduced(acc)) {
           break;

package/choices.d.ts

@@ -9,11 +9,22 @@ import type { IRandom } from "@thi.ng/random";
  * [`weightedRandom()`](https://docs.thi.ng/umbrella/random/functions/weightedRandom.html).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/choices.ts
  * import { choices, frequencies, take, transduce } from "@thi.ng/transducers";
  *
- * transduce(take(1000), frequencies(), choices("abcd", [1, 0.5, 0.25, 0.125]))
- * // Map { 'c' => 132, 'a' => 545, 'b' => 251, 'd' => 72 }
+ * const res = transduce(
+ *   take(1000),
+ *   frequencies(),
+ *   choices("abcd", [1, 0.5, 0.25, 0.125])
+ * );
+ *
+ * console.log(res);
+ * // Map(4) {
+ * //   "a": 544,
+ * //   "b": 263,
+ * //   "c": 131,
+ * //   "d": 62,
+ * // }
  * ```
  *
  * @param choices -

package/concat.d.ts

@@ -5,17 +5,21 @@ import type { Nullable } from "@thi.ng/api";
  * such values produced or contained in an input will remain.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/concat.ts
  * import { concat } from "@thi.ng/transducers";
  *
- * [...concat([1, 2, 3], null, [4, 5])]
+ * console.log(
+ *   [...concat([1, 2, 3], null, [4, 5])]
+ * );
  * // [ 1, 2, 3, 4, 5 ]
  *
- * [...concat([1, 2, 3, undefined], null, [4, 5])]
+ * console.log(
+ *   [...concat([1, 2, 3, undefined], null, [4, 5])]
+ * );
  * // [ 1, 2, 3, undefined, 4, 5 ]
  * ```
  *
- * @param xs -
+ * @param sources -
  */
-export declare function concat<T>(...xs: Nullable<Iterable<T>>[]): IterableIterator<T>;
+export declare function concat<T>(...sources: Nullable<Iterable<T>>[]): IterableIterator<T>;
 //# sourceMappingURL=concat.d.ts.map

package/concat.js

@@ -1,7 +1,7 @@
 import { ensureIterable } from "@thi.ng/arrays/ensure-iterable";
-function* concat(...xs) {
-  for (let x of xs) {
-    x != null && (yield* ensureIterable(x));
+function* concat(...sources) {
+  for (let src of sources) {
+    src != null && (yield* ensureIterable(src));
   }
 }
 export {

package/conj.d.ts

@@ -3,5 +3,5 @@ import type { Reducer } from "./api.js";
  * Reducer. Like {@link push}, but for ES6 Sets.
  */
 export declare function conj<T>(): Reducer<T, Set<T>>;
-export declare function conj<T>(xs: Iterable<T>): Set<T>;
+export declare function conj<T>(src: Iterable<T>): Set<T>;
 //# sourceMappingURL=conj.d.ts.map

package/conj.js

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

package/consume.d.ts

@@ -7,10 +7,14 @@
  * should be applied.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/consume.ts
  * import { consume, repeatedly2d } from "@thi.ng/transducers";
  *
- * consume(repeatedly2d((x, y) => console.log("output:", [x, y]), 2, 3));
+ * // iterators are lazy, no logging will actually be performed yet
+ * const iter = repeatedly2d((x, y) => console.log("output:", [x, y]), 2, 3);
+ *
+ * // force evaluation, discard any results
+ * consume(iter);
  * // output: [ 0, 0 ]
  * // output: [ 1, 0 ]
  * // output: [ 0, 1 ]

package/consume.js

@@ -1,6 +1,5 @@
 const consume = (src) => {
-  for (let _ of src)
-    ;
+  for (let _ of src) ;
 };
 export {
   consume

package/converge.d.ts

@@ -15,16 +15,18 @@ import type { Transducer } from "./api.js";
  * See also: {@link takeWhile}
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/converge.ts
  * import { converge, iterate } from "@thi.ng/transducers";
  *
  * // process as long as difference to prev value is >= 0.01
- * [...converge(
+ * const res = [...converge(
  *       // predicate
  *       (a, b) => Math.abs(a - b) < 0.01,
  *       // input sequence
  *       iterate((x, i) => x + Math.pow(2, -i), 0)
- * )]
+ * )];
+ *
+ * console.log(res);
  * // [ 0, 0.5, 0.75, 0.875, 0.9375, 0.96875, 0.984375, 0.9921875 ]
  * ```
  *

package/convolve.js

@@ -15,20 +15,20 @@ const buildKernel2d = (weights, w, h = w) => {
   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 __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 __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`);
+const __kernelError = () => illegalArgs(`no kernel or kernel config`);
 function convolve1d(opts, indices) {
   if (indices) {
     return iterator1(convolve1d(opts), indices);
@@ -39,12 +39,12 @@ function convolve1d(opts, indices) {
   const rfn = opts.reduce || add;
   let kernel = opts.kernel;
   if (!kernel) {
-    !(opts.weights && opts.kwidth) && kernelError();
+    !(opts.weights && opts.kwidth) && __kernelError();
     kernel = buildKernel1d(opts.weights, opts.kwidth);
   }
   return map(
     (p) => transduce(
-      map(kernelLookup1d(src, p, width, wrap, border)),
+      map(__kernelLookup1d(src, p, width, wrap, border)),
       rfn(),
       kernel
     )
@@ -60,12 +60,12 @@ function convolve2d(opts, indices) {
   const rfn = opts.reduce || add;
   let kernel = opts.kernel;
   if (!kernel) {
-    !(opts.weights && opts.kwidth && opts.kheight) && kernelError();
+    !(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)),
+      map(__kernelLookup2d(src, p[0], p[1], width, height, wrap, border)),
       rfn(),
       kernel
     )

package/count.d.ts

@@ -7,7 +7,7 @@ import type { Reducer } from "./api.js";
  * @param step -
  */
 export declare function count(offset?: number, step?: number): Reducer<any, number>;
-export declare function count(xs: Iterable<any>): number;
-export declare function count(offset: number, xs: Iterable<any>): number;
-export declare function count(offset: number, step: number, xs: Iterable<any>): number;
+export declare function count(src: Iterable<any>): number;
+export declare function count(offset: number, src: Iterable<any>): number;
+export declare function count(offset: number, step: number, src: Iterable<any>): number;
 //# sourceMappingURL=count.d.ts.map

package/curve.d.ts

@@ -14,12 +14,14 @@
  * [`curve()`](https://docs.thi.ng/umbrella/dsp/functions/curve.html).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/curve.ts
  * import { curve } from "@thi.ng/transducers";
  *
- * [...curve(50, 100, 10, 2)]
+ * console.log(
+ *   [...curve(50, 100, 10)]
+ * );
  * // [
- * //   50,
+ * //   50.000,
  * //   73.193,
  * //   85.649,
  * //   92.339,
@@ -29,7 +31,7 @@
  * //   99.454,
  * //   99.753,
  * //   99.913,
- * //   100
+ * //   100.000
  * // ]
  * ```
  *

package/cycle.d.ts

@@ -7,15 +7,19 @@
  * Also see {@link repeat}, {@link repeatedly} for related functions.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/cycle.ts
  * import { cycle, range, take } from "@thi.ng/transducers";
  *
  * // take 5 from infinite sequence
- * [...take(5, cycle([1, 2, 3]))]
+ * console.log(
+ *   [...take(5, cycle([1, 2, 3]))]
+ * );
  * // [1, 2, 3, 1, 2]
  *
  * // only produce 2 cycles
- * [...cycle(range(3), 2)]
+ * console.log(
+ *   [...cycle(range(3), 2)]
+ * );
  * // [ 0, 1, 2, 0, 1, 2 ]
  * ```
  *

package/cycle.js

@@ -1,6 +1,5 @@
 function* cycle(input, num = Infinity) {
-  if (num < 1)
-    return;
+  if (num < 1) return;
   let cache = [];
   for (let i of input) {
     cache.push(i);

package/dedupe.d.ts

@@ -8,10 +8,12 @@ import type { Transducer } from "./api.js";
  * See {@link distinct} to remove **any** duplicates.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/dedupe.ts
  * import { dedupe } from "@thi.ng/transducers";
  *
- * [...dedupe([1, 1, 2, 3, 3, 3, 1])]
+ * console.log(
+ *   [...dedupe([1, 1, 2, 3, 3, 3, 1])]
+ * );
  * // [ 1, 2, 3, 1 ]
  * ```
  *

package/deep-transform.d.ts

@@ -18,11 +18,11 @@ import type { TransformSpec } from "./api.js";
  * given directly without having to wrap it into the usual array structure.
  *
  * @example
- * ```ts
- * import { deepTransform } from "@thi.ng/transducers";
+ * ```ts tangle:../export/deep-transform.ts
+ * import { deepTransform, type TransformSpec } from "@thi.ng/transducers";
  *
  * // source object to be transformed
- * src = {
+ * const src = {
  *    meta: {
  *      author: { name: "Alice", email: "a@b.com" },
  *      date: 1041510896000
@@ -33,7 +33,7 @@ import type { TransformSpec } from "./api.js";
  * };
  *
  * // deep transformation spec
- * spec = [
+ * const spec: TransformSpec = [
  *    // root transform (called last)
  *    ({ type, meta, title, body }) => ["div", { class: type }, title, meta, body],
  *    // object of transform sub-specs
@@ -50,18 +50,19 @@ import type { TransformSpec } from "./api.js";
  * ];
  *
  * // build transformer & apply to src
- * deepTransform(spec)(src);
- *
+ * console.log(
+ *   deepTransform(spec)(src)
+ * );
  * // [ "div",
- * //   { class: "article" },
+ * //   { class: "post" },
  * //   [ "h1", "Hello world" ],
  * //   [ "div.meta",
  * //     [ "a", { href: "mailto:a@.b.com" }, "Alice" ],
- * //     "./2/2003, 12:34:56 PM)" ],
+ * //     "(1/2/2003, 12:34:56 PM)" ],
  * //   "Ratione necessitatibus doloremque itaque." ]
  * ```
  *
  * @param spec - transformation spec
  */
-export declare const deepTransform: (spec: TransformSpec) => (x: any) => any;
+export declare const deepTransform: (spec: TransformSpec) => ((x: any) => any);
 //# sourceMappingURL=deep-transform.d.ts.map

package/distinct.d.ts

@@ -17,10 +17,12 @@ export interface DistinctOpts<T> {
  * {@link DistinctOpts}.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/distinct.ts
  * import { distinct } from "@thi.ng/transducers";
  *
- * [...distinct({ key: (x) => x.id }, [{id: 1, x: 2}, {id: 1, x: 3}])]
+ * console.log(
+ *   [...distinct({ key: (x) => x.id }, [{id: 1, x: 2}, {id: 1, x: 3}])]
+ * );
  * // [ { id: 1, x: 2 } ]
  * ```
  *

package/div.d.ts

@@ -4,5 +4,5 @@ import type { Reducer } from "./api.js";
  * value.
  */
 export declare function div(init: number): Reducer<number, number>;
-export declare function div(init: number, xs: Iterable<number>): number;
+export declare function div(init: number, src: Iterable<number>): number;
 //# sourceMappingURL=div.d.ts.map