@thi.ng/transducers 9.0.5 → 9.0.6

package/lookup.d.ts

@@ -3,10 +3,12 @@
  * lookup value in given array. No bounds checks are done.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/lookup.ts
  * import { lookup1d, map } from "@thi.ng/transducers";
  *
- * [...map(lookup1d([10, 20, 30]), [2,0,1])]
+ * console.log(
+ *   [...map(lookup1d([10, 20, 30]), [2,0,1])]
+ * );
  * // [ 30, 10, 20 ]
  * ```
  *
@@ -23,10 +25,12 @@ export declare const lookup1d: <T>(src: T[]) => (i: number) => T;
  * representation of 2D data (pixel buffer). No bounds checks are done.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/lookup2d.ts
  * import { lookup2d, map, range, range2d } from "@thi.ng/transducers";
  *
- * [...map(lookup2d([...range(9)], 3), range2d(2, -1, 0, 3))]
+ * console.log(
+ *   [...map(lookup2d([...range(9)], 3), range2d(2, -1, 0, 3))]
+ * );
  * // [ 2, 1, 0, 5, 4, 3, 8, 7, 6 ]
  * ```
  *

package/map-indexed.d.ts

@@ -8,15 +8,13 @@ import type { Transducer } from "./api.js";
  * An optional start index `offset` can be provided (default 0).
  *
  * @example
- * ```ts
- * import { assocObj, mapIndexed, transduce } from "@thi.ng/transducers";
+ * ```ts tangle:../export/map-indexed.ts
+ * import { mapIndexed } from "@thi.ng/transducers";
  *
- * transduce(
- *   mapIndexed((i, x) => ["id" + i, x * 10], 42),
- *   assocObj(),
- *   [1, 2, 3]
- * )
- * // { id42: 10, id43: 20, id44: 30 }
+ * console.log(
+ *   [...mapIndexed((i, x) => ["id" + i, x * 10], 42, [1, 2, 3])]
+ * );
+ * // [ [ "id42", 10 ], [ "id43", 20 ], [ "id44", 30 ] ]
  * ```
  *
  * @param fn - transformation function

package/map-keys.d.ts

@@ -8,16 +8,18 @@ import type { Transducer } from "./api.js";
  * copy of each `x`.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/map-keys.ts
  * import { mapKeys } from "@thi.ng/transducers";
  *
- * [...mapKeys(
+ * const res = [...mapKeys(
  *   {
  *     a: (x) => x != null ? x * 10 : x,
  *     b: (x) => x != null ? x * 100: "n/a"
  *   },
  *   [{a: 1, b: 2}, {c: 3, d: 4}]
- * )]
+ * )];
+ *
+ * console.log(res);
  * // [ { a: 10, b: 200 }, { c: 3, d: 4, b: 'n/a', a: undefined } ]
  * ```
  *

package/map-nth.d.ts

@@ -9,15 +9,19 @@ import type { Transducer } from "./api.js";
  * the first transformation occurs (default 0).
  *
  * @example
- * ```ts
- * import { mapNth } from "@thi.ng/transducers";
+ * ```ts tangle:../export/map-nth.ts
+ * import { mapNth, range } from "@thi.ng/transducers";
  *
- * [...mapNth(3, (x) => x * 10, range(1,10))]
- * // [ 10, 2, 3, 40, 5, 6, 70, 8, 9 ]
+ * console.log(
+ *   [...mapNth(3, (x) => `*${x}*`, range(1, 10))]
+ * );
+ * // [ "*1*", 2, 3, "*4*", 5, 6, "*7*", 8, 9 ]
  *
  * // with offset
- * [...mapNth(3, 5, (x) => x * 10, range(1,10))]
- * // [ 1, 2, 3, 4, 5, 60, 7, 8, 90 ]
+ * console.log(
+ *   [...mapNth(3, 5, (x) => x * 100, range(1, 10))]
+ * );
+ * // [ 1, 2, 3, 4, 5, 600, 7, 8, 900 ]
  * ```
  *
  * @param n - step size

package/map-vals.d.ts

@@ -10,10 +10,12 @@ import type { Transducer } from "./api.js";
  * object is then used as the result of this transducer.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/map-vals.ts
  * import { mapVals } from "@thi.ng/transducers";
  *
- * [...mapVals((x)=> x * 10, [{a: 1, b: 2}, {c: 3, d: 4}])]
+ * console.log(
+ *   [...mapVals((x)=> x * 10, [{a: 1, b: 2}, {c: 3, d: 4}])]
+ * );
  * // [ { a: 10, b: 20 }, { c: 30, d: 40 } ]
  * ```
  *

package/map.d.ts

@@ -5,10 +5,12 @@ import type { Transducer } from "./api.js";
  * passes result downstream to next reducer.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/map.ts
  * import { map } from "@thi.ng/transducers";
  *
- * [...map((x) => x * 10, [1, 2, 3])]
+ * console.log(
+ *   [...map((x) => x * 10, [1, 2, 3])]
+ * );
  * // [ 10, 20, 30 ]
  * ```
  *

package/mapcat.d.ts

@@ -1,5 +1,5 @@
 import type { Fn, Nullable } from "@thi.ng/api";
-import type { Transducer } from "./api.js";
+import type { MaybeReduced, Transducer } from "./api.js";
 /**
  * Transducer. Similar to {@link map}, but expects the given mapping function
  * `fn` to return an iterable result (or `null`) and then emits each value of
@@ -7,18 +7,22 @@ import type { Transducer } from "./api.js";
  * be skipped / omitted.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/mapcat.ts
  * import { mapcat } from "@thi.ng/transducers";
  *
- * [...mapcat((x) => [x, x], [1, 2, 3])]
+ * console.log(
+ *   [...mapcat((x) => [x, x], [1, 2, 3])]
+ * );
  * // [ 1, 1, 2, 2, 3, 3 ]
  *
- * [...mapcat((x) => x > 2 ? [x, x, x] : null, [1, 2, 3])]
+ * console.log(
+ *   [...mapcat((x) => x > 2 ? [x, x, x] : null, [1, 2, 3])]
+ * );
  * // [ 3, 3, 3 ]
  * ```
  *
  * @param fn - mapping function
  */
-export declare function mapcat<A, B>(fn: Fn<A, Nullable<Iterable<B>>>): Transducer<A, B>;
-export declare function mapcat<A, B>(fn: Fn<A, Nullable<Iterable<B>>>, src: Iterable<A>): IterableIterator<B>;
+export declare function mapcat<A, B>(fn: Fn<A, MaybeReduced<Nullable<Iterable<B>>>>): Transducer<A, B>;
+export declare function mapcat<A, B>(fn: Fn<A, MaybeReduced<Nullable<Iterable<B>>>>, src: Iterable<A>): IterableIterator<B>;
 //# sourceMappingURL=mapcat.d.ts.map

package/match-first.d.ts

@@ -1,35 +1,34 @@
 import type { Maybe, Predicate } from "@thi.ng/api";
 import type { Transducer } from "./api.js";
 /**
- * Transducer composition / syntax sugar for:
- *
- * @example
- * ```ts
- * import { comp, filter, take } from "@thi.ng/transducers";
- *
- * comp(filter(pred), take(1))
- * // [Function]
- * ```
- *
- * Yields none or only the first value which passed the predicate check
- * and then causes early termination. If `src` input is given, returns
+ * Transducer. Yields none or only the first value which passed the predicate
+ * check and then causes early termination. If `src` input is given, returns
  * first match found (or `undefined`). Also see {@link matchLast}.
  *
+ * @remarks
+ * `matchFirst()` is syntax sugar for: `comp(filter(pred), take(1))`
+ *
  * @example
- * ```ts
- * import { comp, map, matchFirst, push, transduce } from "@thi.ng/transducers";
+ * ```ts tangle:../export/match-first.ts
+ * import {
+ *   comp, map, matchFirst, push, transduce
+ * } from "@thi.ng/transducers";
  *
- * matchFirst((x) => x >= 5, [3, 1, 4, 2, 6, 5])
+ * console.log(
+ *   matchFirst((x) => x >= 5, [3, 1, 4, 2, 6, 5])
+ * );
  * // 6
  *
- * transduce(
+ * const res = transduce(
  *   comp(
  *     matchFirst((x) => x >= 5),
  *     map((x) => x * 10)
  *   ),
  *   push(),
  *   [3, 1, 4, 2, 6, 5]
- * )
+ * );
+ *
+ * console.log(res);
  * // [60]
  * ```
  *

package/match-last.d.ts

@@ -1,26 +1,30 @@
 import type { Maybe, Predicate } from "@thi.ng/api";
 import type { Transducer } from "./api.js";
 /**
- * Similar to {@link matchFirst}, but matches yields none or only the **last**
- * value which passed the predicate check. If `src` input is given, returns last
- * match found (or `undefined`).
+ * Similar to {@link matchFirst}, but matches only the **last** value which
+ * passed the predicate check. If `src` input is given, returns last match found
+ * (or `undefined`).
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/match-last.ts
  * import { comp, map, matchLast, push, transduce } from "@thi.ng/transducers";
  *
- * matchLast((x) => x >= 5, [3, 1, 6, 5, 4, 2])
+ * console.log(
+ *   matchLast((x) => x >= 5, [3, 1, 6, 5, 4, 2])
+ * );
  * // 5
  *
- * transduce(
+ * const res = transduce(
  *   comp(
  *     matchLast((x) => x >= 5),
  *     map((x) => x * 10)
  *   ),
  *   push(),
  *   [3, 1, 6, 5, 4, 2]
- * )
- * // 50
+ * );
+ *
+ * console.log(res);
+ * // [ 50 ]
  * ```
  *
  * @param pred - predicate function

package/max-compare.d.ts

@@ -1,6 +1,6 @@
-import type { Comparator, Fn0 } from "@thi.ng/api";
+import type { Comparator, Fn0, Nullable } from "@thi.ng/api";
 import type { Reducer } from "./api.js";
 export declare function maxCompare<T>(init: Fn0<T>, cmp?: Comparator<T>): Reducer<T, T>;
-export declare function maxCompare<T>(init: Fn0<T>, xs: Iterable<T>): T;
-export declare function maxCompare<T>(init: Fn0<T>, cmp: Comparator<T>, xs: Iterable<T>): T;
+export declare function maxCompare<T>(init: Fn0<T>, src: Iterable<T>): T;
+export declare function maxCompare<T>(init: Fn0<T>, cmp: Nullable<Comparator<T>>, src: Iterable<T>): T;
 //# sourceMappingURL=max-compare.d.ts.map

package/max-compare.js

@@ -1,13 +1,6 @@
-import { compare } from "@thi.ng/compare/compare";
-import { $$reduce, reducer } from "./reduce.js";
+import { __compareOp } from "./internal/mathop.js";
 function maxCompare(...args) {
-  const res = $$reduce(maxCompare, args);
-  if (res !== void 0) {
-    return res;
-  }
-  const init = args[0];
-  const cmp = args[1] || compare;
-  return reducer(init, (acc, x) => cmp(acc, x) >= 0 ? acc : x);
+  return __compareOp(maxCompare, args, 1);
 }
 export {
   maxCompare

package/max-mag.d.ts

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

package/max-mag.js

@@ -1,6 +1,6 @@
 import { reduce, reducer } from "./reduce.js";
-function maxMag(xs) {
-  return xs ? reduce(maxMag(), xs) : reducer(
+function maxMag(src) {
+  return src ? reduce(maxMag(), src) : reducer(
     () => 0,
     (acc, x) => Math.abs(x) > Math.abs(acc) ? x : acc
   );

package/max.d.ts

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

package/max.js

@@ -1,6 +1,6 @@
 import { reduce, reducer } from "./reduce.js";
-function max(xs) {
-  return xs ? reduce(max(), xs) : reducer(
+function max(src) {
+  return src ? reduce(max(), src) : reducer(
     () => -Infinity,
     (acc, x) => Math.max(acc, x)
   );

package/mean.d.ts

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

package/mean.js

@@ -1,7 +1,7 @@
 import { reduce } from "./reduce.js";
-function mean(xs) {
+function mean(src) {
   let n = 1;
-  return xs ? reduce(mean(), xs) : [
+  return src ? reduce(mean(), src) : [
     () => n = 0,
     (acc) => n > 1 ? acc / n : acc,
     (acc, x) => (n++, acc + x)

package/min-compare.d.ts

@@ -1,6 +1,6 @@
-import type { Comparator, Fn0 } from "@thi.ng/api";
+import type { Comparator, Fn0, Nullable } from "@thi.ng/api";
 import type { Reducer } from "./api.js";
 export declare function minCompare<T>(init: Fn0<T>, cmp?: Comparator<T>): Reducer<T, T>;
-export declare function minCompare<T>(init: Fn0<T>, xs: Iterable<T>): T;
-export declare function minCompare<T>(init: Fn0<T>, cmp: Comparator<T>, xs: Iterable<T>): T;
+export declare function minCompare<T>(init: Fn0<T>, src: Iterable<T>): T;
+export declare function minCompare<T>(init: Fn0<T>, cmp: Nullable<Comparator<T>>, src: Iterable<T>): T;
 //# sourceMappingURL=min-compare.d.ts.map

package/min-compare.js

@@ -1,13 +1,6 @@
-import { compare } from "@thi.ng/compare/compare";
-import { $$reduce, reducer } from "./reduce.js";
+import { __compareOp } from "./internal/mathop.js";
 function minCompare(...args) {
-  const res = $$reduce(minCompare, args);
-  if (res !== void 0) {
-    return res;
-  }
-  const init = args[0];
-  const cmp = args[1] || compare;
-  return reducer(init, (acc, x) => cmp(acc, x) <= 0 ? acc : x);
+  return __compareOp(minCompare, args, -1);
 }
 export {
   minCompare

package/min-mag.d.ts

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

package/min-mag.js

@@ -1,6 +1,6 @@
 import { reduce, reducer } from "./reduce.js";
-function minMag(xs) {
-  return xs ? reduce(minMag(), xs) : reducer(
+function minMag(src) {
+  return src ? reduce(minMag(), src) : reducer(
     () => Infinity,
     (acc, x) => Math.abs(x) < Math.abs(acc) ? x : acc
   );

package/min.d.ts

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

package/min.js

@@ -1,6 +1,6 @@
 import { reduce, reducer } from "./reduce.js";
-function min(xs) {
-  return xs ? reduce(min(), xs) : reducer(
+function min(src) {
+  return src ? reduce(min(), src) : reducer(
     () => Infinity,
     (acc, x) => Math.min(acc, x)
   );

package/mul.d.ts

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

package/mul.js

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

package/multiplex-obj.d.ts

@@ -5,20 +5,24 @@ import type { MultiplexTxLike, Reducer, Transducer } from "./api.js";
  * object of transducers and produces a result object for each input.
  *
  * @example
- * ```ts
- * import { multiplexObj } from "@thi.ng/transducers";
+ * ```ts tangle:../export/multiplex-obj.ts
+ * import { multiplexObj, map } from "@thi.ng/transducers";
  *
- * [...multiplexObj(
+ * const res = [...multiplexObj(
  *   {
  *     initial: map(x => x.charAt(0)),
  *     upper:   map(x => x.toUpperCase()),
  *     length:  map(x => x.length)
  *   },
  *   ["Alice", "Bob", "Charlie"]
- * )]
- * // [ { length: 5, upper: 'ALICE', initial: 'A' },
+ * )];
+ *
+ * console.log(res);
+ * // [
+ * //   { length: 5, upper: 'ALICE', initial: 'A' },
  * //   { length: 3, upper: 'BOB', initial: 'B' },
- * //   { length: 7, upper: 'CHARLIE', initial: 'C' } ]
+ * //   { length: 7, upper: 'CHARLIE', initial: 'C' }
+ * // ]
  * ```
  *
  * @param xforms - object of transducers

package/multiplex.d.ts

@@ -21,26 +21,27 @@ import type { MultiplexTxLike, Transducer } from "./api.js";
  * should be used.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/multiplex.ts
  * import { iterator, map, multiplex } from "@thi.ng/transducers";
  *
- * [...iterator(
+ * const res = [...iterator(
  *   multiplex(
  *     map(x => x.charAt(0)),
  *     map(x => x.toUpperCase()),
  *     map(x => x.length)
  *   ),
  *   ["Alice", "Bob", "Charlie"]
- * )]
+ * )];
  *
+ * console.log(res);
  * // [ [ "A", "ALICE", 5 ], [ "B", "BOB", 3 ], [ "C", "CHARLIE", 7 ] ]
  * ```
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/multiplex-2.ts
  * import { iterator, map, mapcat, multiplex } from "@thi.ng/transducers";
  *
- * [...iterator(
+ * const res = [...iterator(
  *   multiplex(
  *     // override default unwrap behavior for this transducer
  *     // (i.e. here to ensure results are always arrays)
@@ -49,8 +50,9 @@ import type { MultiplexTxLike, Transducer } from "./api.js";
  *     map((x) => x),
  *   ),
  *   [[1, 2], [3]]
- * )]
+ * )];
  *
+ * console.log(res);
  * // [ [ [ 1, 2 ], [ 1, 2 ] ], [ [ 3 ], [ 3 ] ] ]
  *
  * // to compare: using the default behavior would produce this instead

package/norm-count.d.ts

@@ -9,18 +9,20 @@ import type { Reducer } from "./api.js";
  * normalized histogram.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/norm-count.ts
  * import { filter, normCount, transduce } from "@thi.ng/transducers";
  *
  * const items = [1,2,3,1,1,4,2,5,1,2];
  *
  * // compute percentage of values < 3
- * transduce(filter(x => x<3), normCount(items.length), items);
+ * console.log(
+ *   transduce(filter(x => x<3), normCount(items.length), items)
+ * );
  * // 0.7
  * ```
  *
  * @param norm -
  */
 export declare function normCount(norm: number): Reducer<any, number>;
-export declare function normCount(norm: number, xs: Iterable<any>): number;
+export declare function normCount(norm: number, src: Iterable<any>): number;
 //# sourceMappingURL=norm-count.d.ts.map

package/norm-frequencies-auto.d.ts

@@ -5,21 +5,25 @@ import type { Reducer } from "./api.js";
  * basis instead of requiring it ahead of time as argument.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/norm-frequencies-auto.ts
  * import { normFrequenciesAuto } from "@thi.ng/transducers";
  *
  * const items = [1, 2, 3, 1, 1, 4, 2, 5, 1, 2];
  *
- * normFrequenciesAuto(items)
+ * console.log(
+ *   normFrequenciesAuto(items)
+ * );
  * // Map(5) { 1 => 0.4, 2 => 0.3, 3 => 0.1, 4 => 0.1, 5 => 0.1 }
  *
  * // frequencies by 1st letter
- * normFrequenciesAuto(x => x[0], ["alice", "abba", "bob", "charlie"])
+ * console.log(
+ *   normFrequenciesAuto(x => x[0], ["alice", "abba", "bob", "charlie"])
+ * );
  * // Map(3) { 'a' => 0.5, 'b' => 0.25, 'c' => 0.25 }
  * ```
  */
 export declare function normFrequenciesAuto<A>(): Reducer<A, Map<A, number>>;
-export declare function normFrequenciesAuto<A>(xs: Iterable<A>): Map<A, number>;
+export declare function normFrequenciesAuto<A>(src: Iterable<A>): Map<A, number>;
 export declare function normFrequenciesAuto<A, B>(key: Fn<A, B>): Reducer<A, Map<B, number>>;
-export declare function normFrequenciesAuto<A, B>(key: Fn<A, B>, xs: Iterable<A>): Map<B, number>;
+export declare function normFrequenciesAuto<A, B>(key: Fn<A, B>, src: Iterable<A>): Map<B, number>;
 //# sourceMappingURL=norm-frequencies-auto.d.ts.map

package/norm-frequencies.d.ts

@@ -8,19 +8,27 @@ import type { Reducer } from "./api.js";
  * Also see {@link normFrequenciesAuto}.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/norm-frequencies.ts
  * import { normFrequencies } from "@thi.ng/transducers";
  *
  * const items = [1, 2, 3, 1, 1, 4, 2, 5, 1, 2];
  *
- * normFrequencies(10, items)
- * // Map(5) { 1 => 0.4, 2 => 0.3, 3 => 0.1, 4 => 0.1, 5 => 0.1 }
+ * console.log(
+ *   normFrequencies(10, items)
+ * );
+ * // Map(5) {
+ * //   1 => 0.4,
+ * //   2 => 0.3,
+ * //   3 => 0.1,
+ * //   4 => 0.1,
+ * //   5 => 0.1,
+ * // }
  * ```
  *
  * @param norm -
  */
 export declare function normFrequencies<A>(norm: number): Reducer<A, Map<A, number>>;
-export declare function normFrequencies<A>(norm: number, xs: Iterable<A>): Map<A, number>;
+export declare function normFrequencies<A>(norm: number, src: Iterable<A>): Map<A, number>;
 export declare function normFrequencies<A, B>(norm: number, key: Fn<A, B>): Reducer<A, Map<B, number>>;
-export declare function normFrequencies<A, B>(norm: number, key: Fn<A, B>, xs: Iterable<A>): Map<B, number>;
+export declare function normFrequencies<A, B>(norm: number, key: Fn<A, B>, src: Iterable<A>): Map<B, number>;
 //# sourceMappingURL=norm-frequencies.d.ts.map

package/norm-range.d.ts

@@ -4,19 +4,27 @@
  * is true, the values are emitted in reverse order, i.e. from 1.0 → 0.0.
  *
  * @example
- * ```ts
+ * ```ts tangle:../export/norm-range.ts
  * import { normRange } from "@thi.ng/transducers";
  *
- * [...normRange(4)]
+ * console.log(
+ *   [...normRange(4)]
+ * );
  * // [0, 0.25, 0.5, 0.75, 1.0]
  *
- * [...normRange(4, false)]
+ * console.log(
+ *   [...normRange(4, false)]
+ * );
  * // [0, 0.25, 0.5, 0.75]
  *
- * [...normRange(4, true, true)]
+ * console.log(
+ *   [...normRange(4, true, true)]
+ * );
  * // [1, 0.75, 0.5, 0.25, 0]
  *
- * [...normRange(4, false, true)]
+ * console.log(
+ *   [...normRange(4, false, true)]
+ * );
  * // [1, 0.75, 0.5, 0.25]
  * ```
  *