@thi.ng/transducers 9.0.5 → 9.0.6

package/rechunk.d.ts

@@ -11,17 +11,20 @@ import type { Transducer } from "./api.js";
  * NodeJS' stream processing.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/rechunk.ts
  * import { rechunk } from "@thi.ng/transducers";
  *
- * [...rechunk(/-/, ["abc-d", "ef-g-", "hij", "-k-lm"])]
+ * console.log(
+ *   [...rechunk(/-/, ["abc-d", "ef-g-", "hij", "-k-lm"])]
+ * );
  * // [ "abc", "def", "g", "hij", "k", "lm" ]
  * ```
  *
  * @example
- * ```ts
- * import { spawn } from "node:child_process"
+ * ```ts tangle:../export/rechunk-2.ts
  * import { fromNodeJS, trace } from "@thi.ng/rstream";
+ * import { rechunk } from "@thi.ng/transducers";
+ * import { spawn } from "node:child_process"
  *
  * const cmd = spawn("ls", ["-la"]);
  *
@@ -44,6 +47,6 @@ import type { Transducer } from "./api.js";
  * @param re -
  */
 export declare function rechunk(re?: RegExp): Transducer<string, string>;
-export declare function rechunk(xs: Iterable<string>): IterableIterator<string>;
-export declare function rechunk(re: RegExp, xs: Iterable<string>): IterableIterator<string>;
+export declare function rechunk(src: Iterable<string>): IterableIterator<string>;
+export declare function rechunk(re: RegExp, src: Iterable<string>): IterableIterator<string>;
 //# sourceMappingURL=rechunk.d.ts.map

package/reduce.d.ts

@@ -1,11 +1,11 @@
 import type { Fn0, FnAny } from "@thi.ng/api";
 import type { IReducible, Reducer, ReductionFn } from "./api.js";
-export declare function reduce<A, B>(rfn: Reducer<A, B>, xs: Iterable<A>): B;
-export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: B, xs: Iterable<A>): B;
-export declare function reduce<A, B>(rfn: Reducer<A, B>, xs: IReducible<A, B>): B;
-export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: A, xs: IReducible<A, B>): B;
-export declare function reduceRight<A, B>(rfn: Reducer<A, B>, xs: ArrayLike<A>): B;
-export declare function reduceRight<A, B>(rfn: Reducer<A, B>, acc: B, xs: ArrayLike<A>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, src: Iterable<A>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: B, src: Iterable<A>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, src: IReducible<A, B>): B;
+export declare function reduce<A, B>(rfn: Reducer<A, B>, acc: A, src: IReducible<A, B>): B;
+export declare function reduceRight<A, B>(rfn: Reducer<A, B>, src: ArrayLike<A>): B;
+export declare function reduceRight<A, B>(rfn: Reducer<A, B>, acc: B, src: ArrayLike<A>): B;
 /**
  * Convenience helper for building a full {@link Reducer} using the identity
  * function (i.e. `(x) => x`) as completion step (true for 90% of all

package/reduce.js

@@ -4,28 +4,28 @@ 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 ? [void 0, args[1]] : args.length === 3 ? [args[1], args[2]] : illegalArity(args.length);
+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);
+  args = __parseArgs(args);
   const acc = args[0] == null ? init() : args[0];
-  const xs = args[1];
+  const src = args[1];
   return unreduced(
     complete(
-      implementsFunction(xs, "$reduce") ? xs.$reduce(reduce2, acc) : isArrayLike(xs) ? reduceArray(reduce2, acc, xs) : reduceIterable(reduce2, acc, xs)
+      implementsFunction(src, "$reduce") ? src.$reduce(reduce2, acc) : isArrayLike(src) ? __reduceArray(reduce2, acc, src) : __reduceIterable(reduce2, acc, src)
     )
   );
 }
 function reduceRight(...args) {
   const [init, complete, reduce2] = args[0];
-  args = parseArgs(args);
+  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]);
+  const src = args[1];
+  for (let i = src.length; i-- > 0; ) {
+    acc = reduce2(acc, src[i]);
     if (isReduced(acc)) {
       acc = acc.deref();
       break;
@@ -33,9 +33,9 @@ function reduceRight(...args) {
   }
   return unreduced(complete(acc));
 }
-const reduceArray = (rfn, acc, xs) => {
-  for (let i = 0, n = xs.length; i < n; i++) {
-    acc = rfn(acc, xs[i]);
+const __reduceArray = (rfn, acc, src) => {
+  for (let i = 0, n = src.length; i < n; i++) {
+    acc = rfn(acc, src[i]);
     if (isReduced(acc)) {
       acc = acc.deref();
       break;
@@ -43,8 +43,8 @@ const reduceArray = (rfn, acc, xs) => {
   }
   return acc;
 };
-const reduceIterable = (rfn, acc, xs) => {
-  for (let x of xs) {
+const __reduceIterable = (rfn, acc, src) => {
+  for (let x of src) {
     acc = rfn(acc, x);
     if (isReduced(acc)) {
       acc = acc.deref();

package/reductions.d.ts

@@ -1,4 +1,4 @@
 import type { Reducer } from "./api.js";
 export declare function reductions<A, B>(rfn: Reducer<A, B>): Reducer<A, B[]>;
-export declare function reductions<A, B>(rfn: Reducer<A, B>, xs: Iterable<A>): B[];
+export declare function reductions<A, B>(rfn: Reducer<A, B>, src: Iterable<A>): B[];
 //# sourceMappingURL=reductions.d.ts.map

package/reductions.js

@@ -1,8 +1,8 @@
 import { reduce } from "./reduce.js";
 import { isReduced, reduced } from "./reduced.js";
-function reductions(rfn, xs) {
+function reductions(rfn, src) {
   const [init, complete, _reduce] = rfn;
-  return xs ? reduce(reductions(rfn), xs) : [
+  return src ? reduce(reductions(rfn), src) : [
     () => [init()],
     (acc) => (acc[acc.length - 1] = complete(acc[acc.length - 1]), acc),
     (acc, x) => {

package/repeat.d.ts

@@ -5,10 +5,12 @@
  * See also: {@link repeatedly}
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/repeat.ts
  * import { repeat } from "@thi.ng/transducers";
  *
- * [...repeat(42, 5)]
+ * console.log(
+ *   [...repeat(42, 5)]
+ * );
  * // [42, 42, 42, 42, 42]
  * ```
  *

package/repeatedly.d.ts

@@ -5,14 +5,18 @@ import type { Fn } from "@thi.ng/api";
  * will be produced, else the iterator is infinite.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/repeatedly.ts
  * import { repeatedly } from "@thi.ng/transducers";
  *
- * [...repeatedly(() => Math.floor(Math.random() * 10), 5)]
+ * console.log(
+ *   [...repeatedly(() => Math.floor(Math.random() * 10), 5)]
+ * );
  * // [7, 0, 9, 3, 1]
  *
  * // same result as range(5)
- * [...repeatedly((i) => i, 5)]
+ * console.log(
+ *   [...repeatedly((i) => i, 5)]
+ * );
  * // [0, 1, 2, 3, 4]
  * ```
  *

package/repeatedly2d.d.ts

@@ -5,10 +5,12 @@ import type { FnU2 } from "@thi.ng/api";
  * `y` grid coordinates. The iteration order is always row-major.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/repeatedly2d.ts
  * import { repeatedly2d } from "@thi.ng/transducers";
  *
- * [...repeatedly2d((x, y) => [(x + 1) * 10, (y + 1) * 100], 2, 3)]
+ * console.log(
+ *   [...repeatedly2d((x, y) => [(x + 1) * 10, (y + 1) * 100], 2, 3)]
+ * );
  * // [
  * //   [ 10, 100 ], [ 20, 100 ],
  * //   [ 10, 200 ], [ 20, 200 ],

package/repeatedly3d.d.ts

@@ -5,10 +5,12 @@ import type { FnU3 } from "@thi.ng/api";
  * `z` grid coordinates. The iteration order is always slice major, then row-major.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/repeatedly3d.ts
  * import { repeatedly3d } from "@thi.ng/transducers";
  *
- * [...repeatedly3d((x, y, z) => [(x+1)*10, (y+1)*100, (z+1)*1000], 2, 2, 2)]
+ * console.log(
+ *   [...repeatedly3d((x, y, z) => [(x+1)*10, (y+1)*100, (z+1)*1000], 2, 2, 2)]
+ * );
  * // [
  * //   [ 10, 100, 1000 ], [ 20, 100, 1000 ], [ 10, 200, 1000 ], [ 20, 200, 1000 ],
  * //   [ 10, 100, 2000 ], [ 20, 100, 2000 ], [ 10, 200, 2000 ], [ 20, 200, 2000 ]

package/reverse.d.ts

@@ -3,10 +3,12 @@
  * order. Important: Input MUST be finite.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/reverse.ts
  * import { reverse } from "@thi.ng/transducers";
  *
- * [...reverse("hello world")]
+ * console.log(
+ *   [...reverse("hello world")]
+ * );
  * // [ "d", "l", "r", "o", "w", " ", "o", "l", "l", "e", "h" ]
  * ```
  *

package/run.d.ts

@@ -1,17 +1,17 @@
 import type { Fn } from "@thi.ng/api";
 import type { IReducible, TxLike } from "./api.js";
 /**
- * Transforms `xs` with given transducer and optional side effect
- * without any reduction step. If `fx` is given it will be called with
- * every value produced by the transducer. If `fx` is *not* given, the
- * transducer is assumed to include at least one {@link sideEffect} step
- * itself. Returns nothing.
+ * Transforms `src` with given transducer `tx` and optional side-effect `fx`
+ * without any reduction step. If `fx` is given it will be called with every
+ * value produced by the transducer. If `fx` is *not* given, the transducer is
+ * assumed to include at least one {@link sideEffect} step itself. Returns
+ * nothing.
  *
  * @param tx -
- * @param xs -
+ * @param src -
  */
-export declare function run<A>(tx: TxLike<A, any>, xs: Iterable<A>): void;
-export declare function run<A>(tx: TxLike<A, any>, xs: IReducible<A, any>): void;
-export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, xs: Iterable<A>): void;
-export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, xs: IReducible<A, any>): void;
+export declare function run<A>(tx: TxLike<A, any>, src: Iterable<A>): void;
+export declare function run<A>(tx: TxLike<A, any>, src: IReducible<A, any>): void;
+export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, src: Iterable<A>): void;
+export declare function run<A, B>(tx: TxLike<A, B>, fx: Fn<B, void>, src: IReducible<A, any>): void;
 //# sourceMappingURL=run.d.ts.map

package/sample.d.ts

@@ -6,11 +6,13 @@ import type { Transducer } from "./api.js";
  * [`IRandom`](https://docs.thi.ng/umbrella/random/interfaces/IRandom.html) interface.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/sample.ts
  * import { range, sample } from "@thi.ng/transducers";
  *
  * // 10% probability
- * [...sample(0.1, range(100))]
+ * console.log(
+ *   [...sample(0.1, range(100))]
+ * );
  * // [ 3, 24, 25, 36, 43, 49, 59, 64, 82, 86, 89 ]
  * ```
  *

package/scan.d.ts

@@ -11,33 +11,37 @@ import type { Reducer, Transducer } from "./api.js";
  * https://en.wikipedia.org/wiki/Prefix_sum#Scan_higher_order_function
  *
  * @example
- * ```ts
- * import {
- *   add, comp, last, length, multiplex, range, scan, transduce
- * } from "@thi.ng/transducers";
+ * ```ts tangle:../export/scan.ts
+ * import * as tx from "@thi.ng/transducers";
  *
- * [...iterator(scan(add()), range(10))]
+ * console.log(
+ *   [...tx.iterator(tx.scan(tx.add()), tx.range(10))]
+ * );
  * // [ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45 ]
  *
  * // directly as iterator and with initial result
- * [...scan(add(), 100, range(10))]
+ * console.log(
+ *   [...tx.scan(tx.add(), 100, tx.range(10))]
+ * );
  * // [ 100, 101, 103, 106, 110, 115, 121, 128, 136, 145 ]
  *
  * // as transducer
- * transduce(
+ * const res = tx.transduce(
  *   // parallel processing lanes for each input
- *   multiplex(
- *     // join strings
- *     scan(str(" ")),
- *     // compute total length (+1)
- *     comp(length(1), scan(add()))
+ *   tx.multiplex(
+ *     // first lane: join strings
+ *     tx.scan(tx.str(" ")),
+ *     // second lane: compute total length (+1)
+ *     tx.comp(tx.length(1), tx.scan(tx.add()))
  *   ),
- *   // only keep final value
- *   last(),
+ *   // use last() reducer to only keep final value
+ *   tx.last(),
  *   // inputs
  *   ["alpha", "beta", "gamma", "delta"]
- * )
- * // [ 'alpha beta gamma delta', 23 ]
+ * );
+ *
+ * console.log(res);
+ * // [ 'alpha beta gamma delta', 123 ]
  * ```
  *
  * @param rfn - reducer used as scan operator

package/select-keys.d.ts

@@ -8,17 +8,19 @@ import type { Transducer } from "./api.js";
  * For single key extraction {@link pluck} is a faster alternative.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/select-keys.ts
  * import { selectKeys } from "@thi.ng/transducers";
  *
- * [...selectKeys(
+ * const res = [...selectKeys(
  *   ["id", "age"],
  *   [
  *     {id: 1, age: 23, name: "alice"},
  *     {id: 2, age: 42, name: "bob"},
  *     {id: 3, name: "charlie"},
  *   ]
- * )]
+ * )];
+ *
+ * console.log(res);
  * // [ { age: 23, id: 1 }, { age: 42, id: 2 }, { id: 3 } ]
  * ```
  *

package/sliding-window.d.ts

@@ -11,14 +11,20 @@ import type { Transducer } from "./api.js";
  * window size will be re-evaluated for each new input and therefore can be used
  * as mechanism to dynamically adjust the window size.
  *
+ * Also see {@link partition}.
+ *
  * @example
- * ```ts
+ * ```ts tangle:../export/sliding-window.ts
  * import { range, slidingWindow } from "@thi.ng/transducers";
  *
- * [...slidingWindow(3, range(5))]
+ * console.log(
+ *   [...slidingWindow(3, range(5))]
+ * );
  * // [ [ 0 ], [ 0, 1 ], [ 0, 1, 2 ], [ 1, 2, 3 ], [ 2, 3, 4 ] ]
  *
- * [...slidingWindow(3, false, range(5))]
+ * console.log(
+ *   [...slidingWindow(3, false, range(5))]
+ * );
  * // [ [ 0, 1, 2 ], [ 1, 2, 3 ], [ 2, 3, 4 ] ]
  * ```
  *

package/some.d.ts

@@ -8,6 +8,6 @@ import type { Reducer } from "./api.js";
  * @param pred -
  */
 export declare function some<T>(pred?: Predicate<T>): Reducer<T, boolean>;
-export declare function some<T>(xs: Iterable<T>): boolean;
-export declare function some<T>(pred: Predicate<T>, xs: Iterable<T>): boolean;
+export declare function some<T>(src: Iterable<T>): boolean;
+export declare function some<T>(pred: Predicate<T>, src: Iterable<T>): boolean;
 //# sourceMappingURL=some.d.ts.map

package/step.d.ts

@@ -11,41 +11,56 @@ import type { TxLike } from "./api.js";
  * invocations of the stepper function will return undefined.
  *
  * @example
- * ```ts
- * import { filter, map, macat, step, take } from "@thi.ng/transducers";
+ * ```ts tangle:../export/step.ts
+ * import { filter, map, mapcat, step, take } from "@thi.ng/transducers";
  *
  * // single result (unwrapped, default)
- * step(map(x => x * 10))(1);
+ * console.log(
+ *   step(map((x: number) => x * 10))(1)
+ * );
  * // 10
  *
  * // single result (no unwrapping)
- * step(map(x => x * 10), false)(1);
+ * console.log(
+ *   step(map((x: number) => x * 10), false)(1)
+ * );
  * // [10]
  *
  * // multiple results
- * step(mapcat(x => [x, x + 1, x + 2]))(1)
+ * console.log(
+ *   step(mapcat((x: number) => [x, x + 1, x + 2]))(1)
+ * );
  * // [ 1, 2, 3 ]
  *
  * // multiple results (default behavior)
- * step(mapcat(x => x))([1, 2])
+ * console.log(
+ *   step(mapcat((x: number[]) => take(2, x)))([1, 2, 3, 4])
+ * );
  * // [1, 2]
- * step(mapcat(x => x))([3])
+ *
+ * console.log(
+ *   step(mapcat((x: number[]) => x))([3])
+ * );
  * // 3
+ *
  * // ...once more without unwrapping
- * step(mapcat(x => x), false)([3])
+ * console.log(
+ *   step(mapcat((x: number[]) => x), false)([3])
+ * );
  * // [3]
  *
- * // no result
- * f = step(filter((x) => !(x & 1)))
- * f(1); // undefined
- * f(2); // 2
+ * // filter even values
+ * const f = step(filter((x: number) => !(x & 1)))
+ *
+ * console.log(f(1)); // undefined
+ * console.log(f(2)); // 2
  *
  * // reduced value termination
- * f = step(take(2));
- * f(1); // 1
- * f(1); // 1
- * f(1); // undefined
- * f(1); // undefined
+ * const g = step(take(2));
+ * console.log(g(1)); // 1
+ * console.log(g(1)); // 1
+ * console.log(g(1)); // undefined
+ * console.log(g(1)); // undefined
  * ```
  *
  * @param tx -

package/str.d.ts

@@ -1,4 +1,10 @@
 import type { Reducer } from "./api.js";
+/**
+ * Reducer which concatenates inputs into a string, each value separated by
+ * `sep` (default: "").
+ *
+ * @param sep
+ */
 export declare function str(sep?: string): Reducer<any, string>;
-export declare function str(sep: string, xs: Iterable<any>): string;
+export declare function str(sep: string, src: Iterable<any>): string;
 //# sourceMappingURL=str.d.ts.map

package/str.js

@@ -1,8 +1,8 @@
 import { reducer } from "./reduce.js";
-function str(sep, xs) {
+function str(sep, src) {
   sep = sep || "";
   let first = true;
-  return xs ? [...xs].join(sep) : reducer(
+  return src ? [...src].join(sep) : reducer(
     () => "",
     (acc, x) => (acc = first ? acc + x : acc + sep + x, first = false, acc)
   );

package/stream-shuffle.d.ts

@@ -26,14 +26,18 @@ export interface StreamShuffleOpts {
  * are possible.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/stream-shuffle.ts
  * import { range, streamShuffle } from "@thi.ng/transducers";
  * import { XsAdd } from "@thi.ng/random";
  *
- * [...streamShuffle(5, range(10))]
+ * console.log(
+ *   [...streamShuffle(5, range(10))]
+ * );
  * // [ 3, 2, 5, 0, 8, 7, 1, 6, 4, 9 ]
  *
- * [...streamShuffle({ n: 5, rnd: new XsAdd(12345) }, range(10))]
+ * console.log(
+ *   [...streamShuffle({ n: 5, rnd: new XsAdd(12345) }, range(10))]
+ * );
  * [ 0, 4, 3, 7, 8, 1, 5, 2, 6, 9 ]
  * ```
  *

package/stream-sort.d.ts

@@ -1,14 +1,16 @@
 import type { SortOpts, Transducer } from "./api.js";
 /**
- * Transducer. Similar to {@link partitionSort}, however uses proper sliding
- * window and insertion sort instead of fully sorting window as done by
+ * Transducer. Similar to {@link partitionSort}, however uses a sliding window
+ * of size `n` and insertion sort instead of fully sorting window as done by
  * `partitionSort`.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/stream-sort.ts
  * import { streamSort } from "@thi.ng/transducers";
  *
- * [...streamSort(4, [5,9,2,6,4,1,3,8,7,0])]
+ * console.log(
+ *   [...streamSort(4, [5,9,2,6,4,1,3,8,7,0])]
+ * );
  * // [ 2, 4, 1, 3, 5, 6, 0, 7, 8, 9 ]
  * ```
  *

package/struct.d.ts

@@ -18,22 +18,29 @@ export type StructField<T> = [string, number, Fn<T[], any>?];
  * field values, e.g. from `[123] => 123`
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/struct.ts
  * import { push, struct, transduce } from "@thi.ng/transducers";
  *
- * transduce(
+ * const res = transduce(
  *     struct([["id", 1, (id) => id[0]], ["pos", 2], ["vel", 2], ["color", 4]]),
  *     push(),
  *     [0, 100, 200, -1, 0, 1, 0.5, 0, 1, 1, 0, 0, 5, 4, 0, 0, 1, 1]
- * )
- * // [ { color: [ 1, 0.5, 0, 1 ],
+ * );
+ *
+ * console.log(res);
+ * // [
+ * //   {
+ * //     color: [ 1, 0.5, 0, 1 ],
  * //     vel: [ -1, 0 ],
  * //     pos: [ 100, 200 ],
- * //     id: 0 },
- * //   { color: [ 0, 0, 1, 1 ],
+ * //     id: 0,
+ * //   }, {
+ * //     color: [ 0, 0, 1, 1 ],
  * //     vel: [ 5, 4 ],
  * //     pos: [ 0, 0 ],
- * //     id: 1 } ]
+ * //     id: 1,
+ * //   }
+ * // ]
  * ```
  *
  * @param fields -

package/sub.d.ts

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

package/sub.js

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

package/swizzle.d.ts

@@ -4,16 +4,22 @@ import type { Transducer } from "./api.js";
  * order. Accepts arrays or objects as input, but always yields arrays.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/swizzle.ts
  * import { swizzle } from "@thi.ng/transducers";
  *
- * [...swizzle([3, 0, 2, 1], [[1, 2, 3, 4], [10, 20, 30, 40]])]
+ * console.log(
+ *   [...swizzle([3, 0, 2, 1], [[1, 2, 3, 4], [10, 20, 30, 40]])]
+ * );
  * // [ [ 4, 1, 3, 2 ], [ 40, 10, 30, 20 ] ]
  *
- * [...swizzle([0, 0, 1, 1], [[1, 2, 3, 4], [10, 20, 30, 40]])]
+ * console.log(
+ *   [...swizzle([0, 0, 1, 1], [[1, 2, 3, 4], [10, 20, 30, 40]])]
+ * );
  * // [ [ 1, 1, 2, 2 ], [ 10, 10, 20, 20 ] ]
  *
- * [...swizzle(["z", "x"], [{x: 1, y: 2, z: 3}])]
+ * console.log(
+ *   [...swizzle(["z", "x"], [{x: 1, y: 2, z: 3}])]
+ * );
  * // [ [ 3, 1 ] ]
  * ```
  *

package/symmetric.d.ts

@@ -1,13 +1,23 @@
 /**
  * Yields an iterator of all `src` values, followed by the same values in
  * reverse order. Efficiently builds the reversed order via an internal linked
- * list.
+ * list. The input MUST be finite!
+ *
+ * @remarks
+ * Also see {@link palindrome}.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/symmetric.ts
  * import { symmetric } from "@thi.ng/transducers";
  *
- * [...symmetric([1, 2, 3])]
+ * console.log(
+ *   [...symmetric("abc")]
+ * );
+ * // [ "a", "b", "c", "c", "b", "a" ]
+ *
+ * console.log(
+ *   [...symmetric([1, 2, 3])]
+ * );
  * // [ 1, 2, 3, 3, 2, 1 ]
  * ```
  *

package/take-last.d.ts

@@ -4,10 +4,12 @@ import type { Transducer } from "./api.js";
  * input source is finite (of course).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/take-last.ts
  * import { range, takeLast } from "@thi.ng/transducers";
  *
- * [...takeLast(3, range(10))]
+ * console.log(
+ *   [...takeLast(3, range(10))]
+ * );
  * // [ 7, 8, 9 ]
  * ```
  *