@rimbu/common 0.8.2 → 0.9.2

package/src/async-reducer.ts

@@ -45,61 +45,71 @@ export namespace AsyncReducer {
     onClose?(state: S, error?: unknown): MaybePromise<void>;
     /**
      * Returns an `AsyncReducer` instance that only passes values to the reducer that satisy the given `pred` predicate.
-     * @param pred - a potaentially asynchronous function that returns true if the value should be passed to the reducer based on the following inputs:
-     * - value: the current input value
-     * - index: the current input index
+     * @param pred - a potaentially asynchronous function that returns true if the value should be passed to the reducer based on the following inputs:<br/>
+     * - value: the current input value<br/>
+     * - index: the current input index<br/>
      * - halt: function that, when called, ensures no more new values are passed to the reducer
      * @example
+     * ```ts
      * AsyncReducer
      *   .createMono(0, async (c, v) => c + v)
      *   .filterInput(async v => v > 10)
      * // this reducer will only sum values larger than 10
+     * ```
      */
     filterInput(
       pred: (value: I, index: number, halt: () => void) => MaybePromise<boolean>
     ): AsyncReducer<I, O>;
     /**
      * Returns an `AsyncReducer` instance that converts its input values using given `mapFun` before passing them to the reducer.
-     * @param mapFun - a potentially asynchronous function that returns a new value to pass to the reducer based on the following inputs:
-     * - value: the current input value
+     * @param mapFun - a potentially asynchronous function that returns a new value to pass to the reducer based on the following inputs:<br/>
+     * - value: the current input value<br/>
      * - index: the current input index
      * @example
+     * ```ts
      * AsyncReducer
      *   .createMono(0, async (c, v) => c + v)
      *   .mapInput(async v => v * 2)
      * // this reducer will double all input values before summing them
+     * ```
      */
     mapInput<I2>(
       mapFun: (value: I2, index: number) => MaybePromise<I>
     ): AsyncReducer<I2, O>;
     /**
      * Returns an `AsyncReducer` instance that converts or filters its input values using given `collectFun` before passing them to the reducer.
-     * @param collectFun - a function receiving
-     * * `value`: the next value
-     * * `index`: the value index
-     * * `skip`: a token that, when returned, will not add a value to the resulting collection
-     * * `halt`: a function that, when called, ensures no next elements are passed
+     * @param collectFun - a function receiving<br/>
+     * - `value`: the next value<br/>
+     * - `index`: the value index<br/>
+     * - `skip`: a token that, when returned, will not add a value to the resulting collection<br/>
+     * - `halt`: a function that, when called, ensures no next elements are passed
      * @example
+     * ```ts
      * AsyncReducer
      *   .createMono(0, async (c, v) => c + v)
      *   .collectInput(async (v, _, skip) => v <= 10 ? skip : v * 2)
      * // this reducer will double all input values larger thant 10 before summing them,
      * // and will skip all values smaller than 10
+     * ```
      */
     collectInput<I2>(collectFun: AsyncCollectFun<I2, I>): AsyncReducer<I2, O>;
     /**
      * Returns an `AsyncReducer` instance that converts its output values using given `mapFun`.
      * @param mapFun - a potentially asynchronous function that takes the current output value and converts it to a new output value
+     * @example
+     * ```ts
      * AsyncReducer
      *   .createMono(0, async (c, v) => c + v)
      *   .mapOutput(async v => String(v))
      * // this reducer will convert all its results to string before returning them
+     * ```
      */
     mapOutput<O2>(mapFun: (value: O) => MaybePromise<O2>): AsyncReducer<I, O2>;
     /**
      * Returns an `AsyncReducer` instance that takes at most the given `amount` of input elements, and will ignore subsequent elements.
      * @param amount - the amount of elements to accept
      * @example
+     * ```ts
      * await AsyncStream
      *   .from(Stream.range({ end: 10 }))
      *   .reduce(
@@ -108,12 +118,14 @@ export namespace AsyncReducer {
      *       .takeInput(2)
      *   )
      * // => 1
+     * ```
      */
     takeInput(amount: number): AsyncReducer<I, O>;
     /**
      * Returns a `Reducer` instance that skips the first given `amount` of input elements, and will process subsequent elements.
      * @param amount - the amount of elements to skip
      * @example
+     * ```ts
      * await AsyncStream
      *   .from(Stream.range({ end: 10 }))
      *   .reduce(
@@ -122,6 +134,7 @@ export namespace AsyncReducer {
      *       .dropInput(9)
      *   )
      * // => 19
+     * ```
      */
     dropInput(amount: number): AsyncReducer<I, O>;
     /**
@@ -129,6 +142,7 @@ export namespace AsyncReducer {
      * @param from - (default: 0) the index at which to start processing elements
      * @param amount - (optional) the amount of elements to process, if not given, processes all elements from the `from` index
      * @example
+     * ```ts
      * await AsyncStream
      *   .from(Stream.range({ end: 10 }))
      *   .reduce(
@@ -137,6 +151,7 @@ export namespace AsyncReducer {
      *       .sliceInput(1, 2)
      *   )
      * // => 3
+     * ```
      */
     sliceInput(from?: number, amount?: number): AsyncReducer<I, O>;
   }
@@ -269,10 +284,10 @@ export namespace AsyncReducer {
   /**
    * Returns an `AsyncReducer` with the given options:
    * @param init - the optionally lazy and/or promised initial state value
-   * @param next - returns (potentially asynchronously) the next state value based on the given inputs:
-   * - current: the current state
-   * - next: the current input value
-   * - index: the input index value
+   * @param next - returns (potentially asynchronously) the next state value based on the given inputs:<br/>
+   * - current: the current state<br/>
+   * - next: the current input value<br/>
+   * - index: the input index value<br/>
    * - halt: function that, when called, ensures no more elements are passed to the reducer
    * @param stateToResult - a potentially asynchronous function that converts the current state to an output value
    * @param onClose - (optional) a function that will be called when the reducer will no longer receive values
@@ -297,10 +312,10 @@ export namespace AsyncReducer {
   /**
    * Returns an `AsyncReducer` of which the input, state, and output types are the same.
    * @param init - the optionally lazy and/or promised initial state value
-   * @param next - returns (potentially asynchronously) the next state value based on the given inputs:
-   * - current: the current state
-   * - next: the current input value
-   * - index: the input index value
+   * @param next - returns (potentially asynchronously) the next state value based on the given inputs:<br/>
+   * - current: the current state<br/>
+   * - next: the current input value<br/>
+   * - index: the input index value<br/>
    * - halt: function that, when called, ensures no more elements are passed to the reducer
    * @param stateToResult - a potentially asynchronous function that converts the current state to an output value
    * @param onClose - (optional) a function that will be called when the reducer will no longer receive values
@@ -325,10 +340,10 @@ export namespace AsyncReducer {
   /**
    * Returns an `AsyncReducer` of which the state and output types are the same.
    * @param init - the optionally lazy and/or promised initial state value
-   * @param next - returns (potentially asynchronously) the next state value based on the given inputs:
-   * - current: the current state
-   * - next: the current input value
-   * - index: the input index value
+   * @param next - returns (potentially asynchronously) the next state value based on the given inputs:<br/>
+   * - current: the current state<br/>
+   * - next: the current input value<br/>
+   * - index: the input index value<br/>
    * - halt: function that, when called, ensures no more elements are passed to the reducer
    * @param stateToResult - a potentially asynchronous function that converts the current state to an output value
    * @param onClose - (optional) a function that will be called when the reducer will no longer receive values

package/src/collect.ts

@@ -17,12 +17,12 @@ export type CollectFun<T, R> = (
 
 export namespace CollectFun {
   /**
-   * Indicates, when returned from a collect function, to skip the vale.
+   * Indicates, when returned from a collect function, to skip the value.
    */
   export const Skip = Symbol('Skip');
 
   /**
-   * Indicates, when returned from a collect function, to skip the vale.
+   * Indicates, when returned from a collect function, to skip the value.
    */
   export type Skip = typeof Skip;
 }

package/src/comp.ts

@@ -11,6 +11,7 @@ export interface Comp<K> {
    * @param value1 - the first value to compare
    * @param value2 - the seconds value to compare
    * @example
+   * ```ts
    * const c = Comp.numberComp()
    * console.log(c.compare(5, 5))
    * // => 0
@@ -18,17 +19,20 @@ export interface Comp<K> {
    * // => -2
    * console.log(c.compare(5, 3))
    * // => 2
+   * ```
    */
   compare(value1: K, value2: K): number;
   /**
    * Returns true if this instance can compare given `obj`.
    * @param obj - the object to check
    * @example
+   * ```ts
    * const c = Comp.numberComp()
    * console.log(c.isComparable(5))
    * // => true
    * console.log(c.isComparable('a'))
    * // => false
+   * ```
    */
   isComparable(obj: any): obj is K;
 }
@@ -73,9 +77,11 @@ export namespace Comp {
   /**
    * Returns a default number Comp instance that orders numbers naturally.
    * @example
+   * ```ts
    * const c = Comp.numberComp();
    * console.log(c.compare(3, 5))
    * // => -2
+   * ```
    */
   export function numberComp(): Comp<number> {
     return _numberComp;
@@ -93,11 +99,13 @@ export namespace Comp {
   /**
    * Returns a default boolean Comp instance that orders booleans according to false < true.
    * @example
+   * ```ts
    * const c = Comp.booleanComp();
    * console.log(c.compare(false, true) < 0)
    * // => true
    * console.log(c.compare(true, true))
    * // => 0
+   * ```
    */
   export function booleanComp(): Comp<boolean> {
     return _booleanComp;
@@ -233,7 +241,7 @@ export namespace Comp {
       isComparable(obj): obj is T {
         return obj instanceof cls;
       },
-      compare(v1, v2) {
+      compare(v1, v2): number {
         return valueComp.compare(v1.valueOf(), v2.valueOf());
       },
     };
@@ -256,7 +264,7 @@ export namespace Comp {
           typeof obj === 'object' && obj !== null && Symbol.iterator in obj
         );
       },
-      compare(v1, v2) {
+      compare(v1, v2): number {
         const iter1 = v1[Symbol.iterator]();
         const iter2 = v2[Symbol.iterator]();
 
@@ -283,11 +291,13 @@ export namespace Comp {
    * Returns a Comp instance for Iterable objects that orders the Iterables by comparing the elements with the given `itemComp` Comp instance.
    * @param itemComp - (optional) the Comp instance to use to compare the Iterable's elements.
    * @example
+   * ```ts
    * const c = Comp.iterableComp();
    * console.log(c.compare([1, 3, 2], [1, 3, 2]))
    * // => 0
    * console.log(c.compare([1, 2, 3, 4], [1, 3, 2]) < 0)
    * // => true
+   * ```
    */
   export function iterableComp<T>(itemComp?: Comp<T>): Comp<Iterable<T>> {
     if (undefined === itemComp) return _iterableAnyComp;
@@ -329,7 +339,7 @@ export namespace Comp {
       isComparable(obj): obj is Record<any, any> {
         return true;
       },
-      compare(v1, v2) {
+      compare(v1, v2): number {
         const keys1 = Object.keys(v1);
         const keys2 = Object.keys(v2);
 
@@ -371,14 +381,16 @@ export namespace Comp {
 
   /**
    * Returns a Comp instance for objects that orders the object keys according to the given `keyComp`, and then compares the corresponding
-   * values using the given `valueComp`. Objects are then compared as follows:
-   * - starting with the smallest key of either object:
-   *   - if only one of the objects has the key, the object with the key is considered to be larger than the other
-   *   - if both objects have the key, the values are compared with `valueComp`. If the values are not equal, this result is returned.
-   * - if the objects have the same keys with the same values, they are considered equal
+   * values using the given `valueComp`. Objects are then compared as follows:<br/>
+   * starting with the smallest key of either object:<br/>
+   * - if only one of the objects has the key, the object with the key is considered to be larger than the other<br/>
+   * - if both objects have the key, the values are compared with `valueComp`. If the values are not equal, this result is returned.<br/>
+   *
+   * if the objects have the same keys with the same values, they are considered equal<br/>
    * @param keyComp - (optional) the Comp instance used to order the object keys
    * @param valueComp - (optional) the Comp instance used to order the object values
    * @example
+   * ```ts
    * const c = Comp.objectComp();
    * console.log(c.compare({ a: 1 }, { a: 1 }))
    * // => 0
@@ -390,6 +402,7 @@ export namespace Comp {
    * // => true
    * console.log(c.compare({ a: 1, b: 2 }, { b: 2, a: 1 }))
    * // => 0
+   * ```
    */
   export function objectComp(options?: {
     keyComp?: Comp<any>;
@@ -405,7 +418,7 @@ export namespace Comp {
       isComparable(obj): obj is any {
         return true;
       },
-      compare(v1, v2) {
+      compare(v1, v2): number {
         if (Object.is(v1, v2)) return 0;
 
         const type1 = typeof v1;
@@ -472,10 +485,12 @@ export namespace Comp {
    * Returns a Comp instance that compares any value using default comparison functions, but never recursively compares
    * Iterables or objects. In those cases, it will use the stringComp instance.
    * @example
+   * ```ts
    * const c = Comp.anyFlatComp();
    * console.log(c.compare({ a: 1, b: 1 }, { b: 1, a: 1 }) < 0)
    * // => true
    * // First object is smaller because the objects are converted to a string with and then compares the resulting string.
+   * ```
    */
   export function anyFlatComp<T>(): Comp<T> {
     return _anyFlatComp;
@@ -485,12 +500,14 @@ export namespace Comp {
    * Returns a Comp instance that compares any value using default comparison functions. For Iterables and objects, their elements are compared
    * only one level deep for performance and to avoid infinite recursion.
    * @example
+   * ```ts
    * const c = Comp.anyShallowComp();
    * console.log(c.compare({ a: 1, b: 1 }, { b: 1, a: 1 }))
    * // => 0
    * console.log(c.compare([{ a: 1, b: 1 }], [{ b: 1, a: 1 }]) < 0)
    * // => true
    * // First object is smaller because the objects are converted to a string and then compares the resulting string.
+   * ```
    */
   export function anyShallowComp<T>(): Comp<T> {
     return _anyShallowComp;
@@ -501,11 +518,13 @@ export namespace Comp {
    * recursively.
    * @note can become slow with large nested arrays and objects, and circular structures can cause infinite loops
    * @example
+   * ```ts
    * const c = Comp.anyDeepComp();
    * console.log(c.compare({ a: 1, b: 1 }, { b: 1, a: 1 }))
    * // => 0
    * console.log(c.compare([{ a: 1, b: 1 }], [{ b: 1, a: 1 }]))
    * // => 0
+   * ```
    */
   export function anyDeepComp<T>(): Comp<T> {
     return _anyDeepComp;
@@ -516,18 +535,20 @@ export namespace Comp {
    * than any other value, and equal to another undefined.
    * @param comp - the Comp instance to wrap
    * @example
+   * ```ts
    * const c = Comp.withUndefined(Comp.numberComp())
    * console.log(c.compare(undefined, 5) < 0)
    * // => true
    * console.log(c.compare(undefined, undefined))
    * // => 0
+   * ```
    */
   export function withUndefined<T>(comp: Comp<T>): Comp<T | undefined> {
     return {
       isComparable(obj): obj is T | undefined {
         return undefined === obj || comp.isComparable(obj);
       },
-      compare(v1, v2) {
+      compare(v1, v2): number {
         if (undefined === v1) {
           if (undefined === v2) return 0;
           return -1;
@@ -543,18 +564,20 @@ export namespace Comp {
    * than any other value, and equal to another null.
    * @param comp - the Comp instance to wrap
    * @example
+   * ```ts
    * const c = Comp.withNull(Comp.numberComp())
    * console.log(c.compare(null, 5) < 0)
    * // => true
    * console.log(c.compare(null, null))
    * // => 0
+   * ```
    */
   export function withNull<T>(comp: Comp<T>): Comp<T | null> {
     return {
       isComparable(obj): obj is T | null {
         return null === obj || comp.isComparable(obj);
       },
-      compare(v1, v2) {
+      compare(v1, v2): number {
         if (null === v1) {
           if (null === v2) return 0;
           return -1;
@@ -569,15 +592,17 @@ export namespace Comp {
    * Returns a Comp instance the reverses the order of the given `comp` instance.
    * @param comp - the Comp instance to wrap
    * @example
+   * ```ts
    * const c = Comp.invert(Comp.numberComp())
    * console.log(c.compare(3, 5) > 0)
    * // => true
    * console.log(c.compare(5, 5))
    * // => 0
+   * ```
    */
   export function invert<T>(comp: Comp<T>): Comp<T> {
     return {
-      compare(v1, v2) {
+      compare(v1, v2): number {
         return comp.compare(v2, v1);
       },
       isComparable: comp.isComparable,
@@ -588,11 +613,13 @@ export namespace Comp {
    * Returns an `Eq` equality instance thet will return true when the given `comp` comparable instance returns 0.
    * @param comp - the `Comp` comparable instance to convert
    * @example
+   * ```ts
    * const eq = Comp.toEq(Comp.objectComp())
    * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
    * // => true
+   * ```
    */
   export function toEq<T>(comp: Comp<T>): Eq<T> {
-    return (v1, v2) => comp.compare(v1, v2) === 0;
+    return (v1: T, v2: T): boolean => comp.compare(v1, v2) === 0;
   }
 }

package/src/eq.ts

@@ -32,11 +32,13 @@ export namespace Eq {
   /**
    * An Eq instance that uses `Object.is` to determine if two objects are equal.
    * @example
+   * ```ts
    * const eq = Eq.objectIs
    * console.log(eq(5, 5))
    * // => true
    * console.log(eq(5, 'a'))
    * // => false
+   * ```
    */
   export const objectIs: Eq<any> = Object.is;
 
@@ -48,11 +50,13 @@ export namespace Eq {
    * @typeparam T - the object type containing a valueOf function of type V
    * @typeparam V - the valueOf result type
    * @example
+   * ```ts
    * const eq = Eq.valueOfEq()
    * console.log(eq(new Number(5), new Number(5)))
    * // => true
    * console.log(eq(new Number(5), new Number(3)))
    * // => false
+   * ```
    */
   export function valueOfEq<T extends { valueOf(): V }, V>(): Eq<T> {
     return _valueOfEq;
@@ -61,11 +65,13 @@ export namespace Eq {
   /**
    * Returns an Eq instance that compares Date objects according to their `valueOf` value.
    * @example
+   * ```ts
    * const eq = Eq.dateEq()
    * console.log(eq(new Date(2020, 1, 1), new Date(2020, 1, 1))
    * // => true
    * console.log(eq(new Date(2020, 1, 1), new Date(2020, 2, 1))
    * // => false
+   * ```
    */
   export function dateEq(): Eq<Date> {
     return _valueOfEq;
@@ -96,11 +102,13 @@ export namespace Eq {
    * @typeparam T - the Iterable element type
    * @param itemEq - (optional) the Eq instance to use to compare the Iterable's elements
    * @example
+   * ```ts
    * const eq = Eq.iterableEq();
    * console.log(eq([1, 2, 3], [1, 2, 3])
    * // => true
    * console.log(eq([1, 2, 3], [1, 3, 2])
    * // => false
+   * ```
    */
   export function iterableEq<T>(itemEq?: Eq<T>): Eq<Iterable<T>> {
     if (undefined === itemEq) return _iterableAnyEq;
@@ -141,11 +149,13 @@ export namespace Eq {
    * @typeparam - the object property value type
    * @param valueEq - (optional) the Eq instance to use to compare property values
    * @example
+   * ```ts
    * const eq = Eq.objectEq()
    * console.log(eq({ a: 1, b: { c: 2 }}, { b: { c: 2 }, a: 1 }))
    * // => true
    * console.log(eq({ a: 1, b: { c: 2 }}, { a: 1, b: { c: 3 }}))
    * // => false
+   * ```
    */
   export function objectEq<V = any>(valueEq?: Eq<V>): Eq<Record<any, V>> {
     if (undefined === valueEq) return _objectEq;
@@ -217,11 +227,13 @@ export namespace Eq {
    * it will compare with Object.is.
    * @typeparam T - the value type
    * @example
+   * ```ts
    * const eq = anyFlatEq()
    * console.log(eq(1, 'a'))
    * // => false
    * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
    * // => false
+   * ```
    */
   export function anyFlatEq<T = any>(): Eq<T> {
     return _anyFlatEq;
@@ -233,6 +245,7 @@ export namespace Eq {
    * with Object.is.
    * @typeparam T - the value type
    * @example
+   * ```ts
    * const eq = anyFlatEq()
    * console.log(eq(1, 'a'))
    * // => false
@@ -240,6 +253,7 @@ export namespace Eq {
    * // => true
    * console.log(eq([{ a: 1, b: 2 }], [{ b: 2, a: 1 }]))
    * // => false
+   * ```
    */
   export function anyShallowEq<T = any>(): Eq<T> {
     return _anyShallowEq;
@@ -252,6 +266,7 @@ export namespace Eq {
    * may cause infinite loops
    * @typeparam T - the value type
    * @example
+   * ```ts
    * const eq = anyFlatEq()
    * console.log(eq(1, 'a'))
    * // => false
@@ -259,6 +274,7 @@ export namespace Eq {
    * // => true
    * console.log(eq([{ a: 1, b: 2 }], [{ b: 2, a: 1 }]))
    * // => false
+   * ```
    */
   export function anyDeepEq<T = any>(): Eq<T> {
     return _anyDeepEq;
@@ -274,11 +290,13 @@ export namespace Eq {
    * @param locales - (optional) a locale or list of locales
    * @param options - (optional) see String.localeCompare for details
    * @example
+   * ```ts
    * const eq = Eq.createStringCollatorEq()
    * console.log(eq('a', 'a'))
    * // => true
    * console.log(eq('abc', 'aBc'))
    * // => false
+   * ```
    */
   export function createStringCollatorEq(
     ...args: ConstructorParameters<typeof Intl.Collator>
@@ -297,11 +315,13 @@ export namespace Eq {
   /**
    * Returns an Eq instance that considers strings equal regardless of their case.
    * @example
+   * ```ts
    * const eq = Eq.stringCaseInsentitiveEq()
    * console.log(eq('aB', 'Ab'))
    * // => true
    * console.log(eq('aBc', 'abB'))
    * // => false
+   * ```
    */
   export function stringCaseInsentitiveEq(): Eq<string> {
     return _stringCaseInsensitiveEq;
@@ -324,11 +344,13 @@ export namespace Eq {
   /**
    * Returns an Eq instance that considers strings equal when all their charcodes are equal.
    * @example
+   * ```ts
    * const eq = Eq.stringCharCodeEq()
    * console.log(eq('a', 'a'))
    * // => true
    * console.log(eq('abc', 'aBc'))
    * // => false
+   * ```
    */
   export function stringCharCodeEq(): Eq<string> {
     return _stringCharCodeEq;
@@ -347,11 +369,13 @@ export namespace Eq {
   /**
    * Returns an Eq instance that considers values equal their JSON.stringify values are equal.
    * @example
+   * ```ts
    * const eq = Eq.anyJsonEq()
    * console.log(eq({ a: 1, b: 2 }, { a: 1, b: 2 }))
    * // => true
    * console.log(eq({ a: 1, b: 2 }, { b: 2, a: 1 }))
    * // => false
+   * ```
    */
   export function anyJsonEq(): Eq<any> {
     return _anyJsonEq;
@@ -362,6 +386,7 @@ export namespace Eq {
    * or if [A, B] equals [D, C]
    * @param eq - (optional) an alternative `Eq` instance to use for the values in the tuple
    * @example
+   * ```ts
    * const eq = Eq.tupleSymmetric()
    * console.log(eq([1, 2], [1, 2]))
    * // => true
@@ -369,6 +394,7 @@ export namespace Eq {
    * // => true
    * console.log(eq([1, 3], [2, 1]))
    * // => false
+   * ```
    */
   export function tupleSymmetric<T>(
     eq: Eq<T> = defaultEq()

package/src/err.ts

@@ -1,9 +1,11 @@
 /**
  * Throws an `Err.ForcedError` error when called.
  * @example
+ * ```ts
  * const emptyMap = HashMap.empty<number, string>()
  * emptyMap.get(5, Err);
  * // throws: Err.CustomError(message: 'Err: forced to throw error')
+ * ```
  */
 export function Err(): never {
   return ErrBase.msg('Err: Forced to throw error')();

package/src/index-range.ts

@@ -3,19 +3,20 @@ import type { Range } from './internal';
 /**
  * A flexible range specification for numeric indices.
  * If a start or end is defined, a tuple can be used where the second item is a boolean
- * indicating whether that end is inclusive or exclusive.
- * An IndexRange can have one of the following forms:
- * - { amount: number }
- * - { start: number }
- * - { start: number, amount: number }
- * - { start: number, end: number }
- * - { start: number, end: [number, boolean] }
- * - { start: [number, boolean] }
- * - { start: [number, boolean], amount: number }
- * - { start: [number, boolean], end: number }
- * - { start: [number, boolean], end: [number, boolean] }
- * - { end: number }
- * - { end: [number, boolean] }
+ * indicating whether that end is inclusive or exclusive.<br/>
+ * An IndexRange can have one of the following forms:<br/>
+ * <br/>
+ * - { amount: number }<br/>
+ * - { start: number }<br/>
+ * - { start: number, amount: number }<br/>
+ * - { start: number, end: number }<br/>
+ * - { start: number, end: [number, boolean] }<br/>
+ * - { start: [number, boolean] }<br/>
+ * - { start: [number, boolean], amount: number }<br/>
+ * - { start: [number, boolean], end: number }<br/>
+ * - { start: [number, boolean], end: [number, boolean] }<br/>
+ * - { end: number }<br/>
+ * - { end: [number, boolean] }<br/>
  */
 export type IndexRange =
   | { amount: number; start?: number | [number, boolean]; end?: undefined }

package/src/index.ts

@@ -1 +1,7 @@
+/**
+ * @packageDocumentation
+ *
+ * The `@rimbu/common` package provides many commonly used types and utilities that can also be of use to Rimbu users.<br/>
+ */
+
 export * from './internal';