@thi.ng/transducers 9.0.5 → 9.0.6

package/dup.d.ts

@@ -7,12 +7,17 @@
  * {@link repeatedly} for achieving a different kinds of value duplication.
  *
  * @example
- * ```ts
- * import { dup } from "@thi.ng/transducers";
+ * ```ts tangle:../export/dup.ts
+ * import { dup, range } from "@thi.ng/transducers";
  *
- * dup("hello"); // "hellohello"
- * dup([1, 2, 3]); // [1, 2, 3, 1, 2, 3]
- * dup(range(3)); // IterableIterator<number>
+ * console.log(dup("hello"));
+ * // "hellohello"
+ *
+ * console.log(dup([1, 2, 3]));
+ * // [ 1, 2, 3, 1, 2, 3 ]
+ *
+ * console.log([...dup(range(3))]);
+ * // [ 0, 1, 2, 0, 1, 2 ]
  * ```
  *
  * @param x -

package/every.d.ts

@@ -9,16 +9,18 @@ import type { Reducer } from "./api.js";
  * Returns true if *all* values passed test.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/every.ts
  * import { every } from "@thi.ng/transducers";
  *
- * every((x)=> x > 0, [1,2,-1,3]);
+ * console.log(
+ *   every((x)=> x > 0, [1,2,-1,3])
+ * );
  * // false
  * ```
  *
  * @param pred -
  */
 export declare function every<T>(pred?: Predicate<T>): Reducer<boolean, T>;
-export declare function every<T>(xs: Iterable<T>): boolean;
-export declare function every<T>(pred: Predicate<T>, xs: Iterable<T>): boolean;
+export declare function every<T>(src: Iterable<T>): boolean;
+export declare function every<T>(pred: Predicate<T>, src: Iterable<T>): boolean;
 //# sourceMappingURL=every.d.ts.map

package/every.js

@@ -2,9 +2,7 @@ import { $$reduce, reducer } from "./reduce.js";
 import { reduced } from "./reduced.js";
 function every(...args) {
   const res = $$reduce(every, args);
-  if (res !== void 0) {
-    return res;
-  }
+  if (res !== void 0) return res;
   const pred = args[0];
   return reducer(
     () => true,

package/extend-sides.d.ts

@@ -7,17 +7,25 @@
  * either of them to zero. `numRight` defaults to same value as
  * `numLeft`.
  *
+ * Also see {@link padSides}, {@link wrapSides}.
+ *
  * @example
- * ```ts
+ * ```ts tangle:../export/extend-sides.ts
  * import { extendSides } from "@thi.ng/transducers";
  *
- * [...extendSides([1, 2, 3])]
+ * console.log(
+ *   [...extendSides([1, 2, 3])]
+ * );
  * // [ 1,  1, 2, 3,  3]
  *
- * [...extendSides([1, 2, 3], 3)]
+ * console.log(
+ *   [...extendSides([1, 2, 3], 3)]
+ * );
  * // [ 1, 1, 1,  1, 2, 3,  3, 3, 3 ]
  *
- * [...extendSides([1, 2, 3], 0, 3)]
+ * console.log(
+ *   [...extendSides([1, 2, 3], 0, 3)]
+ * );
  * // [ 1, 2, 3,  3, 3, 3 ]
  * ```
  *

package/fill.d.ts

@@ -8,14 +8,14 @@ import type { Reducer } from "./api.js";
  * @param start -
  */
 export declare function fill<T>(start?: number): Reducer<T, T[]>;
-export declare function fill<T>(xs: Iterable<T>): T[];
-export declare function fill<T>(start: number, xs: Iterable<T>): T[];
+export declare function fill<T>(src: Iterable<T>): T[];
+export declare function fill<T>(start: number, src: Iterable<T>): T[];
 /**
  * Like {@link fill} reducer, but for numeric arrays (incl. typed arrays).
  *
  * @param start -
  */
 export declare function fillN(start?: number): Reducer<number, NumericArray>;
-export declare function fillN(xs: Iterable<number>): NumericArray;
-export declare function fillN(start: number, xs: Iterable<number>): NumericArray;
+export declare function fillN(src: Iterable<number>): NumericArray;
+export declare function fillN(start: number, src: Iterable<number>): NumericArray;
 //# sourceMappingURL=fill.d.ts.map

package/fill.js

@@ -1,9 +1,7 @@
 import { $$reduce, reducer } from "./reduce.js";
 function fill(...args) {
   const res = $$reduce(fill, args);
-  if (res !== void 0) {
-    return res;
-  }
+  if (res !== void 0) return res;
   let start = args[0] || 0;
   return reducer(
     () => [],

package/filter-fuzzy.d.ts

@@ -23,10 +23,12 @@ export interface FilterFuzzyOpts<A, B> {
  * default.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/filter-fuzzy.ts
  * import { filterFuzzy } from "@thi.ng/transducers";
  *
- * [...filterFuzzy("ho", ["hello", "hallo", "hey", "heyoka"])]
+ * console.log(
+ *   [...filterFuzzy("ho", ["hello", "hallo", "hey", "heyoka"])]
+ * );
  * // ["hello", "hallo", "heyoka"]
  * ```
  *

package/flatten-with.d.ts

@@ -13,8 +13,9 @@ export type MaybeIterable<T> = Nullable<Iterable<T>>;
  * of results.
  *
  * @example
- * ```ts
- * import { flattenWith } from "@thi.ng/transducers";
+ * ```ts tangle:../export/flatten-with.ts
+ * import { isPlainObject, isNotStringAndIterable } from "@thi.ng/checks";
+ * import { flattenWith, pairs } from "@thi.ng/transducers";
  *
  * // custom predicate which converts objects into key/val tuples,
  * // returns iterables as is and null for everything else
@@ -25,7 +26,9 @@ export type MaybeIterable<T> = Nullable<Iterable<T>>;
  *       ? x
  *       : null;
  *
- * [...flattenWith(pred, [{ a: 1, b: 2 }, [[{ c: 3 }]]])]
+ * console.log(
+ *   [...flattenWith(pred, [{ a: 1, b: 2 }, [[{ c: 3 }]]])]
+ * );
  * // [ 'a', 1, 'b', 2, 'c', 3 ]
  * ```
  *

package/flatten.d.ts

@@ -9,13 +9,17 @@ import type { Transducer } from "./api.js";
  * iterator of results.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/flatten.ts
  * import { flatten } from "@thi.ng/transducers";
  *
- * [...flatten([[1, [2, 3]], ["abc", "cde"]])]
+ * console.log(
+ *   [...flatten([[1, [2, 3]], ["abc", "cde"]])]
+ * );
  * // [1, 2, 3, "abc", "def"]
  *
- * [...flatten("abc")]
+ * console.log(
+ *   [...flatten("abc")]
+ * );
  * // [ 'abc' ]
  * ```
  */

package/flatten1.d.ts

@@ -5,18 +5,24 @@ import type { Transducer } from "./api.js";
  * 1st level of nesting in input. See {@link mapcat}.
  *
  * @example
- * ```ts
- * import { flatten1 } from "@thi.ng/transducers";
+ * ```ts tangle:../export/flatten1.ts
+ * import { flatten1, mapcat } from "@thi.ng/transducers";
  *
- * [...flatten1([[1], [2, 2], [3, 3, 3]])]
+ * console.log(
+ *   [...flatten1([[1], [2, 2], [3, 3, 3]])]
+ * );
  * // [ 1, 2, 2, 3, 3, 3 ]
  *
  * // same as:
- * [...mapcat((x) => x, [[1], [2, 2], [3, 3, 3]])]
+ * console.log(
+ *   [...mapcat((x) => x, [[1], [2, 2], [3, 3, 3]])]
+ * );
  * // [ 1, 2, 2, 3, 3, 3 ]
  *
  * // nullish inputs will be removed
- * [...flatten1([[1], null, [3, 3, 3]])]
+ * console.log(
+ *   [...flatten1([[1], null, [3, 3, 3]])]
+ * );
  * // [1, 3, 3, 3]
  * ```
  */

package/frequencies.d.ts

@@ -1,7 +1,7 @@
 import type { Fn } from "@thi.ng/api";
 import type { Reducer } from "./api.js";
 export declare function frequencies<A>(): Reducer<A, Map<A, number>>;
-export declare function frequencies<A>(xs: Iterable<A>): Map<A, number>;
+export declare function frequencies<A>(src: Iterable<A>): Map<A, number>;
 export declare function frequencies<A, B>(key: Fn<A, B>): Reducer<A, Map<B, number>>;
-export declare function frequencies<A, B>(key: Fn<A, B>, xs: Iterable<A>): Map<B, number>;
+export declare function frequencies<A, B>(key: Fn<A, B>, src: Iterable<A>): Map<B, number>;
 //# sourceMappingURL=frequencies.d.ts.map

package/group-binary.d.ts

@@ -17,58 +17,68 @@ import type { Reducer } from "./api.js";
  * Index by lowest 4-bits of ID value:
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/group-binary.ts
  * import { groupBinary, reduce } from "@thi.ng/transducers";
  *
- * tree = reduce(
- *   groupBinary(4, x => x.id & 0xf),
- *   [{id: 3}, {id: 8}, {id: 15}, {id: 0}]
- * )
+ * const tree = reduce(
+ *   groupBinary<{ id: number }>(4, x => x.id & 0xf),
+ *   [{ id: 3 }, { id: 8 }, { id: 15 }, { id: 0 }]
+ * );
  *
- * tree.l.l.l.l
+ * console.log(tree.l.l.l.l);
  * // [ { id: 0 } ]
- * tree.r.r.r.r
+ *
+ * console.log(tree.r.r.r.r);
  * // [ { id: 15 } ]
- * tree.l.l.r.r
+ *
+ * console.log(tree.l.l.r.r);
  * // [ { id: 3 } ]
  * ```
  *
  * Collecting as array:
  *
  * @example
- * ```ts
- * import { groupBinary, identity, push, reduce } from "@thi.ng/transducers";
+ * ```ts tangle:../export/group-binary-2.ts
+ * import { groupBinary, reduce } from "@thi.ng/transducers";
  *
- * tree = reduce(
- *   groupBinary(4, identity, () => [], push(), 0, 1),
+ * const tree = reduce(
+ *   groupBinary<number>(4, (x) => x, undefined, undefined, 0, 1),
  *   [1, 2, 3, 4, 5, 6, 7]
- * )
+ * );
  *
- * tree[0][1][0][1] // 0101 == 5 in binary
+ * console.log(tree[0][1][0][1]); // 0101 == 5 in binary
  * // [ 5 ]
  *
- * tree[0][1][1]    // 011* == branch
+ * console.log(tree[0][1][1]);    // 011* == branch
  * // [ [ 6 ], [ 7 ] ]
  * ```
  *
  * Using {@link frequencies} as leaf reducer:
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/group-binary-3.ts
  * import { frequencies, groupBinary, reduce } from "@thi.ng/transducers";
  *
- * tree = reduce(
- *   groupBinary(3, (x: string) => x.length, null, frequencies()),
+ * const tree = reduce(
+ *   groupBinary<string>(3, (x) => x.length, undefined, frequencies()),
  *   "aa bbb dddd ccccc bbb eeee fff".split(" ")
- * )
- * // [ [ undefined,
- * //     [ Map { 'aa' => 1 },
- * //       Map { 'bbb' => 2, 'fff' => 1 } ] ],
- * //   [ [ Map { 'dddd' => 1, 'eeee' => 1 },
- * //       Map { 'ccccc' => 1 } ] ] ]
- *
- * tree[0][1][1]
- * // Map { 'bbb' => 2, 'fff' => 1 }
+ * );
+ *
+ * console.log(tree);
+ * // {
+ * //   l: {
+ * //     r: {
+ * //       l: Map(1) { "aa": 1 },
+ * //       r: Map(2) { "bbb": 2, "fff": 1 },
+ * //     },
+ * //   },
+ * //   r: {
+ * //     l: {
+ * //       l: Map(2) { "dddd": 1, "eeee": 1 },
+ * //       r: Map(1) { "ccccc": 1 },
+ * //     },
+ * //   },
+ * // }
  * ```
  *
  * @param bits - index range (always from 0)

package/group-binary.js

@@ -1,15 +1,15 @@
 import { groupByObj } from "./group-by-obj.js";
 import { push } from "./push.js";
-const branchPred = (key, b, l, r) => (x) => key(x) & b ? r : l;
+const __branchPred = (key, b, l, r) => (x) => key(x) & b ? r : l;
 const groupBinary = (bits, key, branch, leaf, left = "l", right = "r") => {
   const init = branch || (() => ({}));
   let rfn = groupByObj({
-    key: branchPred(key, 1, left, right),
+    key: __branchPred(key, 1, left, right),
     group: leaf || push()
   });
   for (let i = 2, maxIndex = 1 << bits; i < maxIndex; i <<= 1) {
     rfn = groupByObj({
-      key: branchPred(key, i, left, right),
+      key: __branchPred(key, i, left, right),
       group: [init, rfn[1], rfn[2]]
     });
   }

package/group-by-map.d.ts

@@ -1,5 +1,5 @@
 import type { GroupByOpts, Reducer } from "./api.js";
 export declare function groupByMap<SRC, KEY, GROUP>(opts?: Partial<GroupByOpts<SRC, KEY, GROUP>>): Reducer<SRC, Map<KEY, GROUP>>;
-export declare function groupByMap<SRC, GROUP>(xs: Iterable<SRC>): Map<SRC, GROUP>;
-export declare function groupByMap<SRC, KEY, GROUP>(opts: Partial<GroupByOpts<SRC, KEY, GROUP>>, xs: Iterable<SRC>): Map<KEY, GROUP>;
+export declare function groupByMap<SRC, GROUP>(src: Iterable<SRC>): Map<SRC, GROUP>;
+export declare function groupByMap<SRC, KEY, GROUP>(opts: Partial<GroupByOpts<SRC, KEY, GROUP>>, src: Iterable<SRC>): Map<KEY, GROUP>;
 //# sourceMappingURL=group-by-map.d.ts.map

package/group-by-obj.d.ts

@@ -1,6 +1,58 @@
 import type { IObjectOf } from "@thi.ng/api";
 import type { GroupByOpts, Reducer } from "./api.js";
+/**
+ * Reducer. Groups inputs, optionally by given key fn and custom reducer. By
+ * default the values are used as key directly and {@link push} is used as
+ * default reducer.
+ *
+ * @example
+ * ```ts tangle:../export/group-by-obj.ts
+ * import { groupByObj } from "@thi.ng/transducers";
+ *
+ * console.log(
+ *   groupByObj(
+ *     // group items by first char
+ *     { key: (x) => x[0] },
+ *     ["alma", "charlie", "brontë", "anna", "cora", "aurora"]
+ *   )
+ * );
+ * // {
+ * //   a: [ "alma", "anna", "aurora" ],
+ * //   c: [ "charlie", "cora" ],
+ * //   b: [ "brontë" ],
+ * // }
+ * ```
+ *
+ * @example
+ * ```ts tangle:../export/group-by-obj-2.ts
+ * import { conj, groupByObj, repeatedly } from "@thi.ng/transducers";
+ *
+ * console.log(
+ *   groupByObj(
+ *     {
+ *       // bin items by multiples of 10
+ *       key: (x) => Math.floor(x / 10) * 10,
+ *       // keep only uniques (using conj reducer)
+ *       group: conj(),
+ *     },
+ *     repeatedly(() => Math.floor(Math.random() * 100), 20)
+ *   )
+ * );
+ * // {
+ * //   "0":  Set(1) { 8 },
+ * //   "10": Set(1) { 13 },
+ * //   "20": Set(2) { 24, 22 },
+ * //   "30": Set(2) { 38, 36 },
+ * //   "50": Set(5) { 54, 53, 52, 56, 59 },
+ * //   "60": Set(2) { 63, 60 },
+ * //   "70": Set(4) { 79, 71, 74, 78 },
+ * //   "80": Set(2) { 85, 81 },
+ * // }
+ * ```
+ *
+ * @param opts
+ */
 export declare function groupByObj<SRC, GROUP>(opts?: Partial<GroupByOpts<SRC, PropertyKey, GROUP>>): Reducer<SRC, IObjectOf<GROUP>>;
-export declare function groupByObj<SRC>(xs: Iterable<SRC>): IObjectOf<SRC[]>;
-export declare function groupByObj<SRC, GROUP>(opts: Partial<GroupByOpts<SRC, PropertyKey, GROUP>>, xs: Iterable<SRC>): IObjectOf<GROUP>;
+export declare function groupByObj<SRC>(src: Iterable<SRC>): IObjectOf<SRC[]>;
+export declare function groupByObj<SRC, GROUP>(opts: Partial<GroupByOpts<SRC, PropertyKey, GROUP>>, src: Iterable<SRC>): IObjectOf<GROUP>;
 //# sourceMappingURL=group-by-obj.d.ts.map

package/internal/mathop.d.ts

@@ -10,5 +10,15 @@ import type { Reducer, ReductionFn } from "../api.js";
  *
  * @internal
  */
-export declare const __mathop: (rfn: FnAny<Reducer<number, number>>, fn: ReductionFn<number, number>, initDefault: number, args: any[]) => any;
+export declare const __mathOp: (rfn: FnAny<Reducer<number, number>>, fn: ReductionFn<number, number>, initDefault: number, args: any[]) => any;
+/**
+ * Shared impl for {@link minCompare} & {@link maxCompare}.
+ *
+ * @param rfn
+ * @param args
+ * @param sign
+ *
+ * @internal
+ */
+export declare const __compareOp: (rfn: FnAny<Reducer<any, any>>, args: any[], sign: 1 | -1) => any;
 //# sourceMappingURL=mathop.d.ts.map

package/internal/mathop.js

@@ -1,12 +1,19 @@
+import { compare } from "@thi.ng/compare/compare";
 import { $$reduce, reducer } from "../reduce.js";
-const __mathop = (rfn, fn, initDefault, args) => {
+const __mathOp = (rfn, fn, initDefault, args) => {
   const res = $$reduce(rfn, args);
-  if (res !== void 0) {
-    return res;
-  }
+  if (res !== void 0) return res;
   const init = args[0] || initDefault;
   return reducer(() => init, fn);
 };
+const __compareOp = (rfn, args, sign) => {
+  const res = $$reduce(rfn, args);
+  if (res !== void 0) return res;
+  const init = args[0];
+  const cmp = args[1] || compare;
+  return reducer(init, (acc, x) => sign * cmp(acc, x) >= 0 ? acc : x);
+};
 export {
-  __mathop
+  __compareOp,
+  __mathOp
 };

package/interpolate.d.ts

@@ -21,16 +21,17 @@ import type { Transducer } from "./api.js";
  * - {@link extendSides}
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/interpolate.ts
  * import { interpolate } from "@thi.ng/transducers";
  *
- * [...interpolate(
+ * const res = [...interpolate(
  *   ([a, b], t) => a + (b - a) * t,
  *   2,
  *   8,
  *   [0, 1, 0, 2]
- * )]
+ * )];
  *
+ * console.log(res);
  * // [ 0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875,
  * //  1, 0.875, 0.75, 0.625, 0.5, 0.375, 0.25, 0.125,
  * //  0, 0.25, 0.5, 0.75, 1, 1.25, 1.5, 1.75 ]

package/iterate.d.ts

@@ -10,13 +10,17 @@ import type { Fn2 } from "@thi.ng/api";
  * iteration counter as 2nd arg (starting w/ i=1).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/iterate.ts
  * import { iterate } from "@thi.ng/transducers";
  *
- * [...iterate((x) => x * 2, 1, 5)]
+ * console.log(
+ *   [...iterate((x) => x * 2, 1, 5)]
+ * );
  * // [ 1, 2, 4, 8, 16 ]
  *
- * [...iterate((x, i) => x * 10 + i, 0, 8)]
+ * console.log(
+ *   [...iterate((x, i) => x * 10 + i, 0, 8)]
+ * );
  * // [ 0, 1, 12, 123, 1234, 12345, 123456, 1234567 ]
  * ```
  *

package/iterator.d.ts

@@ -5,9 +5,9 @@ import type { Transducer, TxLike } from "./api.js";
  * transformed results.
  *
  * @param xform -
- * @param xs -
+ * @param src -
  */
-export declare function iterator<A, B>(xform: TxLike<A, B>, xs: Iterable<A>): IterableIterator<B>;
+export declare function iterator<A, B>(xform: TxLike<A, B>, src: Iterable<A>): IterableIterator<B>;
 /**
  * Optimized version of {@link iterator} for transducers which are
  * guaranteed to:
@@ -16,9 +16,9 @@ export declare function iterator<A, B>(xform: TxLike<A, B>, xs: Iterable<A>): It
  * 2) Do not require a `completion` reduction step
  *
  * @param xform -
- * @param xs -
+ * @param src -
  */
-export declare function iterator1<A, B>(xform: TxLike<A, B>, xs: Iterable<A>): IterableIterator<B>;
+export declare function iterator1<A, B>(xform: TxLike<A, B>, src: Iterable<A>): IterableIterator<B>;
 /**
  * Helper function used by various transducers to wrap themselves as
  * transforming iterators. Delegates to {@link iterator1} by default.

package/iterator.js

@@ -3,11 +3,11 @@ import { isIterable } from "@thi.ng/checks/is-iterable";
 import { ensureTransducer } from "./ensure.js";
 import { push } from "./push.js";
 import { isReduced, unreduced } from "./reduced.js";
-function* iterator(xform, xs) {
+function* iterator(xform, src) {
   const rfn = ensureTransducer(xform)(push());
   const complete = rfn[1];
   const reduce = rfn[2];
-  for (let x of xs) {
+  for (let x of src) {
     const y = reduce([], x);
     if (isReduced(y)) {
       yield* unreduced(complete(y.deref()));
@@ -19,9 +19,9 @@ function* iterator(xform, xs) {
   }
   yield* unreduced(complete([]));
 }
-function* iterator1(xform, xs) {
+function* iterator1(xform, src) {
   const reduce = ensureTransducer(xform)([NO_OP, NO_OP, (_, x) => x])[2];
-  for (let x of xs) {
+  for (let x of src) {
     let y = reduce(SEMAPHORE, x);
     if (isReduced(y)) {
       y = unreduced(y.deref());

package/juxtr.d.ts

@@ -11,10 +11,16 @@ import type { Reducer } from "./api.js";
  * any number of reducers.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/juxtr.ts
  * import { add, juxtR, reduce, reductions, str } from "@thi.ng/transducers";
  *
- * reduce(juxtR(add(), reductions(add()), str("-")), [1, 2, 3, 4]);
+ * console.log(
+ *   reduce(
+ *     // use 3 reducers in parallel
+ *     juxtR(add(), reductions(add()), str("-")),
+ *     [1, 2, 3, 4]
+ *   )
+ * );
  * // [ 10, [ 0, 1, 3, 6, 10 ], '1-2-3-4' ]
  * ```
  */

package/key-permutations.d.ts

@@ -12,10 +12,12 @@ import type { IObjectOf } from "@thi.ng/api";
  * on the VM's iteration behavior of `Object.keys()`.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/key-permutations.ts
  * import { keyPermutations } from "@thi.ng/transducers";
  *
- * [...keyPermutations({ a: [1, 2], b: [true, false], c: ["X", "Y"] })]
+ * console.log(
+ *   [...keyPermutations({ a: [1, 2], b: [true, false], c: ["X", "Y"] })]
+ * );
  * // [
  * //   { a: 1, b: true, c: 'X' },
  * //   { a: 1, b: true, c: 'Y' },

package/last.d.ts

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

package/last.js

@@ -1,7 +1,7 @@
 import { NO_OP } from "@thi.ng/api/api";
 import { reduce, reducer } from "./reduce.js";
-function last(xs) {
-  return xs ? reduce(last(), xs) : reducer(NO_OP, (_, x) => x);
+function last(src) {
+  return src ? reduce(last(), src) : reducer(NO_OP, (_, x) => x);
 }
 export {
   last

package/length.d.ts

@@ -6,10 +6,12 @@ import type { ILength } from "@thi.ng/api";
  * sequence of these values.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/length.ts
  * import { length } from "@thi.ng/transducers";
  *
- * [...length(0, ["a", "bc", "def"])]
+ * console.log(
+ *   [...length(0, ["a", "bc", "def"])]
+ * );
  * // [1, 2, 3]
  * ```
  *

package/line.d.ts

@@ -11,10 +11,12 @@
  * [`line()`](https://docs.thi.ng/umbrella/dsp/functions/line.html).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/line.ts
  * import { line } from "@thi.ng/transducers";
  *
- * [...line(50, 100, 10)]
+ * console.log(
+ *   [...line(50, 100, 10)]
+ * );
  * // [
  * //    50, 55, 60, 65, 70,
  * //    75, 80, 85, 90, 95,