rambda 10.0.0-beta.1 → 10.0.0

package/README.md

@@ -101,14 +101,6 @@ Because of the focus on `R.pipe`, there is only one way to use each method. This
 - All methods that 2 inputs, will have to be called with `R.methodName(input1)(input2)`
 - All methods that 3 inputs, will have to be called with `R.methodName(input1, input2)(input3)`
 
-### Immutable TS definitions
-
-You can use immutable version of Rambda definitions, which is linted with ESLint `functional/prefer-readonly-type` plugin.
-
-```
-import {filter} from 'rambda/immutable'
-```
-
 ### Deno support 
 
 ```
@@ -258,6 +250,134 @@ it('R.addProp', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#addProp)
 
+### addPropToObjects
+
+```typescript
+
+addPropToObjects<
+  T extends object,
+  K extends string,
+  R
+>(
+	property: K,
+  fn: (input: T) => R
+): (list: T[]) => MergeTypes<T & { [P in K]: R }>[]
+```
+
+It receives list of objects and add new property to each item. 
+
+The value is based on result of `fn` function, which receives the current object as argument.
+
+```javascript
+const result = R.pipe(
+	[
+		{a: 1, b: 2},
+		{a: 3, b: 4},
+	],
+	R.addPropToObjects(
+		'c',
+		(x) => String(x.a + x.b),
+	)
+)
+// => [{a: 1, b: 2, c: '3'}, {a: 3, b: 4, c: '7'}]
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%5B%0A%09%09%7Ba%3A%201%2C%20b%3A%202%7D%2C%0A%09%09%7Ba%3A%203%2C%20b%3A%204%7D%2C%0A%09%5D%2C%0A%09R.addPropToObjects(%0A%09%09'c'%2C%0A%09%09(x)%20%3D%3E%20String(x.a%20%2B%20x.b)%2C%0A%09)%0A)%0A%2F%2F%20%3D%3E%20%5B%7Ba%3A%201%2C%20b%3A%202%2C%20c%3A%20'3'%7D%2C%20%7Ba%3A%203%2C%20b%3A%204%2C%20c%3A%20'7'%7D%5D">Try this <strong>R.addPropToObjects</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+addPropToObjects<
+  T extends object,
+  K extends string,
+  R
+>(
+	property: K,
+  fn: (input: T) => R
+): (list: T[]) => MergeTypes<T & { [P in K]: R }>[];
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.addPropToObjects</strong> source</summary>
+
+```javascript
+import { mapFn } from './map.js'
+
+export function addPropToObjects (
+	property, 
+	fn
+){
+	return listOfObjects => mapFn(
+		(obj) => ({
+			...(obj),
+			[property]: fn(obj)
+		}), 
+		listOfObjects
+	)
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { pipe } from "./pipe.js"
+import { addPropToObjects } from "./addPropToObjects.js"
+
+test('R.addPropToObjects', () => {
+		let result = pipe(
+			[
+				{a: 1, b: 2},
+				{a: 3, b: 4},
+			],
+			addPropToObjects(
+				'c',
+				(x) => String(x.a + x.b),
+			)
+		)
+		expect(result).toEqual([
+			{ a: 1, b: 2, c: '3' },
+			{ a: 3, b: 4, c: '7' },
+		])
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { addPropToObjects, pipe } from 'rambda'
+
+it('R.addPropToObjects', () => {
+		let result = pipe(
+			[
+				{a: 1, b: 2},
+				{a: 3, b: 4},
+			],
+			addPropToObjects(
+				'c',
+				(x) => String(x.a + x.b),
+			)
+		)
+		result // $ExpectType { a: number; b: number; c: string; }[]
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#addPropToObjects)
+
 ### all
 
 ```typescript
@@ -1610,12 +1730,8 @@ function isFalsy(input) {
   return input === undefined || input === null || Number.isNaN(input) === true
 }
 
-export function defaultTo(defaultArgument, input) {
-  if (arguments.length === 1) {
-    return _input => defaultTo(defaultArgument, _input)
-  }
-
-  return isFalsy(input) ? defaultArgument : input
+export function defaultTo(defaultArgument) {
+  return input => isFalsy(input) ? defaultArgument : input
 }
 ```
 
@@ -1641,15 +1757,15 @@ test('with NaN', () => {
 })
 
 test('with empty string', () => {
-  expect(defaultTo('foo', '')).toBe('')
+  expect(defaultTo('foo')('')).toBe('')
 })
 
 test('with false', () => {
-  expect(defaultTo('foo', false)).toBeFalsy()
+  expect(defaultTo('foo')(false)).toBeFalsy()
 })
 
 test('when inputArgument passes initial check', () => {
-  expect(defaultTo('foo', 'bar')).toBe('bar')
+  expect(defaultTo('foo')('bar')).toBe('bar')
 })
 ```
 
@@ -1755,12 +1871,8 @@ drop<T>(howMany: number): (list: T[]) => T[];
 <summary><strong>R.drop</strong> source</summary>
 
 ```javascript
-export function drop(howManyToDrop, listOrString) {
-  if (arguments.length === 1) {
-    return _list => drop(howManyToDrop, _list)
-  }
-
-  return listOrString.slice(howManyToDrop > 0 ? howManyToDrop : 0)
+export function drop(howManyToDrop, ) {
+  return list => list.slice(howManyToDrop > 0 ? howManyToDrop : 0)
 }
 ```
 
@@ -1771,31 +1883,18 @@ export function drop(howManyToDrop, listOrString) {
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import assert from 'node:assert'
-
 import { drop } from './drop.js'
 
 test('with array', () => {
   expect(drop(2)(['foo', 'bar', 'baz'])).toEqual(['baz'])
-  expect(drop(3, ['foo', 'bar', 'baz'])).toEqual([])
-  expect(drop(4, ['foo', 'bar', 'baz'])).toEqual([])
-})
-
-test('with string', () => {
-  expect(drop(3, 'rambda')).toBe('bda')
+  expect(drop(3)(['foo', 'bar', 'baz'])).toEqual([])
+  expect(drop(4)(['foo', 'bar', 'baz'])).toEqual([])
 })
 
 test('with non-positive count', () => {
-  expect(drop(0, [1, 2, 3])).toEqual([1, 2, 3])
-  expect(drop(-1, [1, 2, 3])).toEqual([1, 2, 3])
-  expect(drop(Number.NEGATIVE_INFINITY, [1, 2, 3])).toEqual([1, 2, 3])
-})
-
-test('should return copy', () => {
-  const xs = [1, 2, 3]
-
-  assert.notStrictEqual(drop(0, xs), xs)
-  assert.notStrictEqual(drop(-1, xs), xs)
+  expect(drop(0)([1, 2, 3])).toEqual([1, 2, 3])
+  expect(drop(-1)([1, 2, 3])).toEqual([1, 2, 3])
+  expect(drop(Number.NEGATIVE_INFINITY)([1, 2, 3])).toEqual([1, 2, 3])
 })
 ```
 
@@ -3907,6 +4006,229 @@ describe('flatten', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#flatten)
 
+### flattenObject
+
+```typescript
+
+flattenObject<T extends object>(obj: T): FlattenObject<T>
+```
+
+It transforms object to object where each value is represented with its path.
+
+```javascript
+const result = R.flattenObject(
+	[1, 2, 3]
+)
+// => [3, 1, 2] or [2, 3, 1] or ...
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.flattenObject(%0A%09%5B1%2C%202%2C%203%5D%0A)%0A%2F%2F%20%3D%3E%20%5B3%2C%201%2C%202%5D%20or%20%5B2%2C%203%2C%201%5D%20or%20...">Try this <strong>R.flattenObject</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+flattenObject<T extends object>(obj: T): FlattenObject<T>;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.flattenObject</strong> source</summary>
+
+```javascript
+import { type } from './type.js'
+
+export function flattenObjectHelper(obj, accumulator = []){
+  const willReturn = {}
+  Object.keys(obj).forEach(key => {
+    const typeIs = type(obj[ key ])
+    if (typeIs === 'Object'){
+      const [ flatResultValue, flatResultPath ] = flattenObjectHelper(obj[ key ],
+        [ ...accumulator, key ])
+      willReturn[ flatResultPath.join('.') ] = flatResultValue
+
+      return
+    } else if (accumulator.length > 0){
+      const finalKey = [ ...accumulator, key ].join('.')
+      willReturn[ finalKey ] = obj[ key ]
+
+      return
+    }
+    willReturn[ key ] = obj[ key ]
+  })
+  if (accumulator.length > 0) return [ willReturn, accumulator ]
+
+  return willReturn
+}
+
+export function transformFlatObject(obj){
+  const willReturn = {}
+
+  const transformFlatObjectFn = objLocal => {
+    const willReturnLocal = {}
+    Object.keys(objLocal).forEach(key => {
+      const typeIs = type(objLocal[ key ])
+      if (typeIs === 'Object'){
+        transformFlatObjectFn(objLocal[ key ])
+
+        return
+      }
+      willReturnLocal[ key ] = objLocal[ key ]
+      willReturn[ key ] = objLocal[ key ]
+    })
+
+    return willReturnLocal
+  }
+
+  Object.keys(obj).forEach(key => {
+    const typeIs = type(obj[ key ])
+    if (typeIs === 'Object'){
+      transformFlatObjectFn(obj[ key ], key)
+
+      return
+    }
+    willReturn[ key ] = obj[ key ]
+  })
+
+  return willReturn
+}
+
+export function flattenObject(obj){
+  const willReturn = {}
+
+  Object.keys(obj).forEach(key => {
+    const typeIs = type(obj[ key ])
+    if (typeIs === 'Object'){
+      const flatObject = flattenObjectHelper(obj[ key ])
+      const transformed = transformFlatObject(flatObject)
+
+      Object.keys(transformed).forEach(keyTransformed => {
+        willReturn[ `${ key }.${ keyTransformed }` ] = transformed[ keyTransformed ]
+      })
+    } else {
+      willReturn[ key ] = obj[ key ]
+    }
+  })
+
+  return willReturn
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import {
+  flattenObject,
+  flattenObjectHelper,
+  transformFlatObject,
+} from './flattenObject.js'
+
+test('happy', () => {
+  const obj = {
+    c : 3,
+    d : {
+      'd.e' : [ 5, 6, 7 ],
+      'd.z' : 4,
+      'd.f' : { 'd.f.h' : 6 },
+    },
+  }
+  const result = transformFlatObject(obj)
+  expect(result).toEqual({
+    'c'     : 3,
+    'd.e'   : [ 5, 6, 7 ],
+    'd.z'   : 4,
+    'd.f.h' : 6,
+  })
+})
+
+test('happy', () => {
+  const result = flattenObject({
+    a : 1,
+    b : {
+      c : 3,
+      d : {
+        e : 5,
+        z : 4,
+        f : {
+          h : 6,
+          i : 7,
+          j : {
+            k : 8,
+            l : 9,
+          },
+        },
+      },
+    },
+  })
+    const expected = {
+      'a'         : 1,
+      'b.c'       : 3,
+      'b.d.e'     : 5,
+      'b.d.z'     : 4,
+      'b.d.f.h'   : 6,
+      'b.d.f.i'   : 7,
+      'b.d.f.j.k' : 8,
+      'b.d.f.j.l' : 9,
+    }
+    expect(result).toEqual(expected)
+})
+
+test('flattenObjectHelper', () => {
+  const result = flattenObjectHelper({
+    a : 1,
+    b : {
+      c : 3,
+      d : {
+        e : 5,
+        z : 4,
+        f : { h : 6 },
+      },
+    },
+  })
+  const expected = {
+    a : 1,
+    b : {
+      'b.c' : 3,
+      'b.d' : {
+        'b.d.e' : 5,
+        'b.d.z' : 4,
+        'b.d.f' : { 'b.d.f.h' : 6 },
+      },
+    },
+  }
+  expect(result).toEqual(expected)
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { flattenObject, pipe } from 'rambda'
+
+it('R.flattenObject', () => {
+  const result = pipe({ a: { b: 1, c: 2 } }, flattenObject)
+  result['a.b'] // $ExpectType number
+  result['a.c'] // $ExpectType number
+  // @ts-expect-error
+  result['a.foo']
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#flattenObject)
+
 ### groupBy
 
 ```typescript
@@ -4623,9 +4945,7 @@ const expected = 'foo is BAR even 1 more'
 interpolate(inputWithTags: string): (templateArguments: object) => string;
 
 // API_MARKER_END
-// ============================================
-
-export as namespace R
+// ===========================================
 ```
 
 </details>
@@ -5196,16 +5516,20 @@ map<T extends IterableContainer, U>(
 <summary><strong>R.map</strong> source</summary>
 
 ```javascript
+export function mapFn(
+	fn, list
+){
+	let index = 0
+	const willReturn = Array(list.length)
+	while (index < list.length) {
+		willReturn[index] = fn(list[index], index)
+		index++
+	}
+	return willReturn
+}
+
 export function map(fn) {
-  return list => {
-    let index = 0
-    const willReturn = Array(list.length)
-    while (index < list.length) {
-      willReturn[index] = fn(list[index], index)
-      index++
-    }
-    return willReturn
-  }
+  return list => mapFn(fn, list)
 }
 ```
 
@@ -6153,66 +6477,53 @@ test('happy', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#minBy)
 
-### modifyProp
+### modifyItemAtIndex
 
 ```typescript
 
-modifyProp<T, K extends keyof T>(
-  prop: K,
-  fn: (x: T[K]) => T[K],
-): (target: T) => T
+modifyItemAtIndex<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[]
 ```
 
-It changes a property with the result of transformer function.
+It replaces `index` in array `list` with the result of `replaceFn(list[i])`.
 
 ```javascript
-const person = {
-  name : 'foo',
-  age  : 20,
-}
-const result = R.modifyProp('age', x => x + 1)(person) 
-// => {name: 'foo', age: 21}
+const result = R.pipe(
+	[1, 2, 3],
+	R.modifyItemAtIndex(1, R.add(1))
+) // => [1, 3, 3]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20person%20%3D%20%7B%0A%20%20name%20%3A%20'foo'%2C%0A%20%20age%20%20%3A%2020%2C%0A%7D%0Aconst%20result%20%3D%20R.modifyProp('age'%2C%20x%20%3D%3E%20x%20%2B%201)(person)%20%0A%2F%2F%20%3D%3E%20%7Bname%3A%20'foo'%2C%20age%3A%2021%7D">Try this <strong>R.modifyProp</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%5B1%2C%202%2C%203%5D%2C%0A%09R.modifyItemAtIndex(1%2C%20R.add(1))%0A)%20%2F%2F%20%3D%3E%20%5B1%2C%203%2C%203%5D">Try this <strong>R.modifyItemAtIndex</strong> example in Rambda REPL</a>
 
 <details>
 
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-modifyProp<T, K extends keyof T>(
-  prop: K,
-  fn: (x: T[K]) => T[K],
-): (target: T) => T;
+modifyItemAtIndex<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
 ```
 
 </details>
 
 <details>
 
-<summary><strong>R.modifyProp</strong> source</summary>
+<summary><strong>R.modifyItemAtIndex</strong> source</summary>
 
 ```javascript
-import { isArray } from './_internals/isArray.js'
-import { update } from './update.js'
+import { cloneList } from './_internals/cloneList.js'
 
-function modifyFn(property, fn, list) {
-  if (list[property] === undefined) {
-    return list
-  }
-  if (isArray(list)) {
-    return update(property, fn(list[property]))(list)
-  }
+export function modifyItemAtIndex(index, replaceFn) {
+  return list => {
+    const actualIndex = index < 0 ? list.length + index : index
+    if (index >= list.length || actualIndex < 0) {
+      return list
+    }
 
-  return {
-    ...list,
-    [property]: fn(list[property]),
-  }
-}
+    const clone = cloneList(list)
+    clone[actualIndex] = replaceFn(clone[actualIndex])
 
-export function modifyProp(property, fn) {
-  return obj => modifyFn(property, fn, obj)
+    return clone
+  }
 }
 ```
 
@@ -6223,16 +6534,112 @@ export function modifyProp(property, fn) {
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import { modifyProp } from './modifyProp.js'
+import { modifyItemAtIndex } from './modifyItemAtIndex.js'
 
-const person = {
-  name: 'foo',
-  age: 20,
-}
+const add10 = x => x + 10
+
+const list = [0, 1, 2]
+const expected = [0, 11, 2]
 
 test('happy', () => {
-  expect(modifyProp('age', x => x + 1)(person)).toEqual({
-    name: 'foo',
+  expect(modifyItemAtIndex(1, add10)(list)).toEqual(expected)
+})
+
+test('with negative index', () => {
+  expect(modifyItemAtIndex(-2, add10)(list)).toEqual(expected)
+})
+
+test('when index is out of bounds', () => {
+  const list = [0, 1, 2, 3]
+  expect(modifyItemAtIndex(4, add10)(list)).toEqual(list)
+  expect(modifyItemAtIndex(-5, add10)(list)).toEqual(list)
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#modifyItemAtIndex)
+
+### modifyProp
+
+```typescript
+
+modifyProp<T, K extends keyof T>(
+  prop: K,
+  fn: (x: T[K]) => T[K],
+): (target: T) => T
+```
+
+It changes a property with the result of transformer function.
+
+```javascript
+const person = {
+  name : 'foo',
+  age  : 20,
+}
+const result = R.modifyProp('age', x => x + 1)(person) 
+// => {name: 'foo', age: 21}
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20person%20%3D%20%7B%0A%20%20name%20%3A%20'foo'%2C%0A%20%20age%20%20%3A%2020%2C%0A%7D%0Aconst%20result%20%3D%20R.modifyProp('age'%2C%20x%20%3D%3E%20x%20%2B%201)(person)%20%0A%2F%2F%20%3D%3E%20%7Bname%3A%20'foo'%2C%20age%3A%2021%7D">Try this <strong>R.modifyProp</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+modifyProp<T, K extends keyof T>(
+  prop: K,
+  fn: (x: T[K]) => T[K],
+): (target: T) => T;
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.modifyProp</strong> source</summary>
+
+```javascript
+import { isArray } from './_internals/isArray.js'
+import { update } from './update.js'
+
+function modifyFn(property, fn, list) {
+  if (list[property] === undefined) {
+    return list
+  }
+  if (isArray(list)) {
+    return update(property, fn(list[property]))(list)
+  }
+
+  return {
+    ...list,
+    [property]: fn(list[property]),
+  }
+}
+
+export function modifyProp(property, fn) {
+  return obj => modifyFn(property, fn, obj)
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { modifyProp } from './modifyProp.js'
+
+const person = {
+  name: 'foo',
+  age: 20,
+}
+
+test('happy', () => {
+  expect(modifyProp('age', x => x + 1)(person)).toEqual({
+    name: 'foo',
     age: 21,
   })
 })
@@ -7048,32 +7455,30 @@ path<
 ```javascript
 import { createPath } from './_internals/createPath.js'
 
-export function path(pathInput, obj) {
-  if (arguments.length === 1) {
-    return _obj => path(pathInput, _obj)
-  }
-
-  if (!obj) {
-    return undefined
-  }
-  let willReturn = obj
-  let counter = 0
-
-  const pathArrValue = createPath(pathInput)
-
-  while (counter < pathArrValue.length) {
-    if (willReturn === null || willReturn === undefined) {
-      return undefined
-    }
-    if (willReturn[pathArrValue[counter]] === null) {
-      return undefined
-    }
-
-    willReturn = willReturn[pathArrValue[counter]]
-    counter++
-  }
-
-  return willReturn
+export function path(pathInput) {
+	return (obj)  => {
+		if (!obj) {
+			return undefined
+		}
+		let willReturn = obj
+		let counter = 0
+	
+		const pathArrValue = createPath(pathInput)
+	
+		while (counter < pathArrValue.length) {
+			if (willReturn === null || willReturn === undefined) {
+				return undefined
+			}
+			if (willReturn[pathArrValue[counter]] === null) {
+				return undefined
+			}
+	
+			willReturn = willReturn[pathArrValue[counter]]
+			counter++
+		}
+	
+		return willReturn
+	}
 }
 ```
 
@@ -7089,14 +7494,14 @@ import { path } from './path.js'
 test('with array inside object', () => {
   const obj = { a: { b: [1, { c: 1 }] } }
 
-  expect(path('a.b.1.c', obj)).toBe(1)
+  expect(path('a.b.1.c')(obj)).toBe(1)
 })
 
 test('works with undefined', () => {
   const obj = { a: { b: { c: 1 } } }
 
-  expect(path('a.b.c.d.f', obj)).toBeUndefined()
-  expect(path('foo.babaz', undefined)).toBeUndefined()
+  expect(path('a.b.c.d.f')(obj)).toBeUndefined()
+  expect(path('foo.babaz')(undefined)).toBeUndefined()
   expect(path('foo.babaz')(undefined)).toBeUndefined()
 })
 
@@ -7111,12 +7516,12 @@ test('path', () => {
 })
 
 test('with number string in between', () => {
-  expect(path(['a', '1', 'b'], { a: [{ b: 1 }, { b: 2 }] })).toBe(2)
+  expect(path(['a', '1', 'b'])({ a: [{ b: 1 }, { b: 2 }] })).toBe(2)
 })
 
 test('null is not a valid path', () => {
   expect(
-    path('audio_tracks', {
+    path('audio_tracks')({
       a: 1,
       audio_tracks: null,
     }),
@@ -7153,6 +7558,131 @@ describe('R.path with string as path', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#path)
 
+### pathSatisfies
+
+```typescript
+
+pathSatisfies<S, K0 extends string & keyof S>(
+  predicate: (x: S[K0]) => boolean,
+  path: [K0]
+): (obj: S) => boolean
+```
+
+```javascript
+const result = R.pathSatisfies(
+  x => x > 0,
+  ['a', 'b', 'c'],
+  {a: {b: {c: 1}}}
+)
+// => true
+```
+
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pathSatisfies(%0A%20%20x%20%3D%3E%20x%20%3E%200%2C%0A%20%20%5B'a'%2C%20'b'%2C%20'c'%5D%2C%0A%20%20%7Ba%3A%20%7Bb%3A%20%7Bc%3A%201%7D%7D%7D%0A)%0A%2F%2F%20%3D%3E%20true">Try this <strong>R.pathSatisfies</strong> example in Rambda REPL</a>
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+pathSatisfies<S, K0 extends string & keyof S>(
+  predicate: (x: S[K0]) => boolean,
+  path: [K0]
+): (obj: S) => boolean;
+pathSatisfies<S, K0 extends string & keyof S>(
+  predicate: (x: S[K0]) => boolean,
+  path: `${K0}`
+): (obj: S) => boolean;
+pathSatisfies<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(
+  predicate: (x: S[K0][K1]) => boolean,
+  path: [K0, K1]
+): (obj: S) => boolean;
+pathSatisfies<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(
+  predicate: (x: S[K0][K1]) => boolean,
+  path: `${K0}.${K1}`
+): (obj: S) => boolean;
+...
+...
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.pathSatisfies</strong> source</summary>
+
+```javascript
+import { path } from './path.js'
+
+export function pathSatisfies(fn, pathInput) {
+  return obj => Boolean(fn(path(pathInput)(obj)))
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { pathSatisfies } from './pathSatisfies.js'
+
+const isPositive = n => n > 0
+
+it('returns true if the specified object path satisfies the given predicate', () => {
+  expect(pathSatisfies(isPositive, ['x', 'y'])({ x: { y: 1 } })).toBe(true)
+})
+
+it('returns false if the specified path does not exist', () => {
+  expect(pathSatisfies(isPositive, ['x', 'y'])({ x: { z: 42 } })).toBe(false)
+  expect(pathSatisfies(isPositive, 'x.y')({ x: { z: 42 } })).toBe(false)
+})
+
+it('returns false otherwise', () => {
+  expect(pathSatisfies(isPositive, ['x', 'y'])({ x: { y: 0 } })).toBe(false)
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { pathSatisfies, pipe } from 'rambda'
+
+const input = { a: { b: { c: 'bar' } } }
+
+describe('R.pathSatisfies', () => {
+  it('happy', () => {
+    const result = pipe(
+      input,
+      pathSatisfies(
+        x => {
+          x // $ExpectType string
+          return x !== 'foo'
+        },
+        ['a', 'b', 'c'],
+      ),
+    )
+    const resultStringInput = pipe(
+      input,
+      pathSatisfies(x => {
+        x // $ExpectType string
+        return x !== 'foo'
+      }, 'a.b.c'),
+    )
+    result // $ExpectType boolean
+    resultStringInput // $ExpectType boolean
+  })
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#pathSatisfies)
+
 ### permutations
 
 ```typescript
@@ -8265,7 +8795,7 @@ export function propOr(defaultValue, property) {
       return defaultValue
     }
 
-    return defaultTo(defaultValue, obj[property])
+    return defaultTo(defaultValue)(obj[property])
   }
 }
 ```
@@ -8409,14 +8939,15 @@ describe('R.propSatisfies', () => {
 range(startInclusive: number): (endExclusive: number) => number[]
 ```
 
-It returns list of numbers between `startInclusive` to `endInclusive` markers.
+It returns list of numbers between `startInclusive` to `endExclusive` markers.
+If `start` is greater than `end`, then the result will be in descending order.
 
 ```javascript
-R.range(0)(5)
-// => [0, 1, 2, 3, 4, 5]
+[R.range(0)(5), R.range(5)(0)]
+// => [[0, 1, 2, 3, 4], [5, 4, 3, 2, 1]]
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.range(0)(5)%0A%2F%2F%20%3D%3E%20%5B0%2C%201%2C%202%2C%203%2C%204%2C%205%5D">Try this <strong>R.range</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20%5BR.range(0)(5)%2C%20R.range(5)(0)%5D%0A%2F%2F%20%3D%3E%20%5B%5B0%2C%201%2C%202%2C%203%2C%204%5D%2C%20%5B5%2C%204%2C%203%2C%202%2C%201%5D%5D">Try this <strong>R.range</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -8433,42 +8964,33 @@ range(startInclusive: number): (endExclusive: number) => number[];
 <summary><strong>R.range</strong> source</summary>
 
 ```javascript
-export function range(start) {
-  return end => {
-    if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
-      throw new TypeError('Both arguments to range must be numbers')
-    }
+function rangeDescending(start, end) {
+	const len = start - end
+	const willReturn = Array(len)
 
-    if (end <= start) {
-      return []
-    }
-
-    const len = end - start
-    const willReturn = Array(len)
-
-    for (let i = 0; i < len + 1; i++) {
-      willReturn[i] = start + i
-    }
+	for (let i = 0; i < len; i++) {
+		willReturn[i] = start - i
+	}
 
-    return willReturn
-  }
+	return willReturn
 }
 
-export function rangeDescending(start) {
+export function range(start) {
   return end => {
     if (Number.isNaN(Number(start)) || Number.isNaN(Number(end))) {
       throw new TypeError('Both arguments to range must be numbers')
     }
 
-    if (end >= start) {
+    if (end === start) {
       return []
     }
+		if (end < start) return rangeDescending(start,end)
 
-    const len = start - end
+    const len = end - start
     const willReturn = Array(len)
 
-    for (let i = 0; i < len + 1; i++) {
-      willReturn[i] = start - i
+    for (let i = 0; i < len; i++) {
+      willReturn[i] = start + i
     }
 
     return willReturn
@@ -8483,24 +9005,12 @@ export function rangeDescending(start) {
 <summary><strong>Tests</strong></summary>
 
 ```javascript
-import { range, rangeDescending } from './range.js'
+import { range } from './range.js'
 
 test('happy', () => {
-  expect(range(0)(10)).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-})
-
-test('end range is bigger than start range', () => {
-  expect(range(7)(3)).toEqual([])
-  expect(range(5)(5)).toEqual([])
-})
-
-test('descending', () => {
-	expect(rangeDescending(5)(0)).toEqual([5, 4, 3, 2, 1, 0])
-})
-
-test('descending end range is bigger than start range', () => {
-	expect(rangeDescending(3)(7)).toEqual([])
-	expect(rangeDescending(5)(5)).toEqual([])
+  expect(range(0)(5)).toEqual([0, 1, 2, 3, 4])
+	expect(range(7)(3)).toEqual([7, 6, 5, 4])
+	expect(range(5)(5)).toEqual([])
 })
 ```
 
@@ -8526,34 +9036,6 @@ describe('R.range', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#range)
 
-### rangeDescending
-
-```typescript
-
-rangeDescending(startInclusive: number): (endExclusive: number) => number[]
-```
-
-Same as `R.range` but in descending order.
-
-```javascript
-R.rangeDescending(5, 0)
-// => [5, 4, 3, 2, 1, 0]
-```
-
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.rangeDescending(5%2C%200)%0A%2F%2F%20%3D%3E%20%5B5%2C%204%2C%203%2C%202%2C%201%2C%200%5D">Try this <strong>R.rangeDescending</strong> example in Rambda REPL</a>
-
-<details>
-
-<summary>All TypeScript definitions</summary>
-
-```typescript
-rangeDescending(startInclusive: number): (endExclusive: number) => number[];
-```
-
-</details>
-
-[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#rangeDescending)
-
 ### reduce
 
 ```typescript
@@ -9026,89 +9508,6 @@ describe('R.replace', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#replace)
 
-### replaceItemAtIndex
-
-```typescript
-
-replaceItemAtIndex<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[]
-```
-
-It replaces `index` in array `list` with the result of `replaceFn(list[i])`.
-
-```javascript
-const result = R.pipe(
-	[1, 2, 3],
-	R.replaceItemAtIndex(1, R.add(1))
-) // => [1, 3, 3]
-```
-
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20result%20%3D%20R.pipe(%0A%09%5B1%2C%202%2C%203%5D%2C%0A%09R.replaceItemAtIndex(1%2C%20R.add(1))%0A)%20%2F%2F%20%3D%3E%20%5B1%2C%203%2C%203%5D">Try this <strong>R.replaceItemAtIndex</strong> example in Rambda REPL</a>
-
-<details>
-
-<summary>All TypeScript definitions</summary>
-
-```typescript
-replaceItemAtIndex<T>(index: number, replaceFn: (x: T) => T): (list: T[]) => T[];
-```
-
-</details>
-
-<details>
-
-<summary><strong>R.replaceItemAtIndex</strong> source</summary>
-
-```javascript
-import { cloneList } from './_internals/cloneList.js'
-
-export function replaceItemAtIndex(index, replaceFn) {
-  return list => {
-    const actualIndex = index < 0 ? list.length + index : index
-    if (index >= list.length || actualIndex < 0) {
-      return list
-    }
-
-    const clone = cloneList(list)
-    clone[actualIndex] = replaceFn(clone[actualIndex])
-
-    return clone
-  }
-}
-```
-
-</details>
-
-<details>
-
-<summary><strong>Tests</strong></summary>
-
-```javascript
-import { replaceItemAtIndex } from './replaceItemAtIndex.js'
-
-const add10 = x => x + 10
-
-const list = [0, 1, 2]
-const expected = [0, 11, 2]
-
-test('happy', () => {
-  expect(replaceItemAtIndex(1, add10)(list)).toEqual(expected)
-})
-
-test('with negative index', () => {
-  expect(replaceItemAtIndex(-2, add10)(list)).toEqual(expected)
-})
-
-test('when index is out of bounds', () => {
-  const list = [0, 1, 2, 3]
-  expect(replaceItemAtIndex(4, add10)(list)).toEqual(list)
-  expect(replaceItemAtIndex(-5, add10)(list)).toEqual(list)
-})
-```
-
-</details>
-
-[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#replaceItemAtIndex)
-
 ### shuffle
 
 ```typescript
@@ -9142,6 +9541,8 @@ shuffle<T>(list: T[]): T[];
 <summary><strong>R.shuffle</strong> source</summary>
 
 ```javascript
+import { cloneList } from './_internals/cloneList.js'
+
 export function shuffle(listInput) {
   const list = cloneList(listInput)
   let counter = list.length
@@ -9306,7 +9707,7 @@ const list = [
 ]
 const sortFn = x => x.a
 
-const result = R.sortBy(sortFn, list)
+const result = R.sortBy(sortFn)(list)
 const expected = [
   {a: 1},
   {a: 2},
@@ -9315,7 +9716,7 @@ const expected = [
 // => `result` is equal to `expected`
 ```
 
-<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%0A%20%20%7Ba%3A%202%7D%2C%0A%20%20%7Ba%3A%203%7D%2C%0A%20%20%7Ba%3A%201%7D%0A%5D%0Aconst%20sortFn%20%3D%20x%20%3D%3E%20x.a%0A%0Aconst%20result%20%3D%20R.sortBy(sortFn%2C%20list)%0Aconst%20expected%20%3D%20%5B%0A%20%20%7Ba%3A%201%7D%2C%0A%20%20%7Ba%3A%202%7D%2C%0A%20%20%7Ba%3A%203%7D%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.sortBy</strong> example in Rambda REPL</a>
+<a title="redirect to Rambda Repl site" href="https://rambda.now.sh?const%20list%20%3D%20%5B%0A%20%20%7Ba%3A%202%7D%2C%0A%20%20%7Ba%3A%203%7D%2C%0A%20%20%7Ba%3A%201%7D%0A%5D%0Aconst%20sortFn%20%3D%20x%20%3D%3E%20x.a%0A%0Aconst%20result%20%3D%20R.sortBy(sortFn)(list)%0Aconst%20expected%20%3D%20%5B%0A%20%20%7Ba%3A%201%7D%2C%0A%20%20%7Ba%3A%202%7D%2C%0A%20%20%7Ba%3A%203%7D%0A%5D%0A%2F%2F%20%3D%3E%20%60result%60%20is%20equal%20to%20%60expected%60">Try this <strong>R.sortBy</strong> example in Rambda REPL</a>
 
 <details>
 
@@ -9334,21 +9735,30 @@ sortBy<T>(sortFn: (x: T) => Ord): (list: T[]) => T[];
 ```javascript
 import { cloneList } from './_internals/cloneList.js'
 
-export function sortBy(sortFn) {
-  return list => {
-    const clone = cloneList(list)
+export function sortByFn (
+	sortFn,
+	list,
+	descending
+){
+	const clone = cloneList(list)
 
-    return clone.sort((a, b) => {
-      const aSortResult = sortFn(a)
-      const bSortResult = sortFn(b)
+	return clone.sort((a, b) => {
+		const aSortResult = sortFn(a)
+		const bSortResult = sortFn(b)
 
-      if (aSortResult === bSortResult) {
-        return 0
-      }
+		if (aSortResult === bSortResult) {
+			return 0
+		}
+		if(
+			descending
+		) return aSortResult > bSortResult ? -1 : 1
 
-      return aSortResult < bSortResult ? -1 : 1
-    })
-  }
+		return aSortResult < bSortResult ? -1 : 1
+	})
+}
+
+export function sortBy(sortFn) {
+  return list => sortByFn(sortFn, list, false)
 }
 ```
 
@@ -9361,13 +9771,18 @@ export function sortBy(sortFn) {
 ```javascript
 import { sortBy } from './sortBy.js'
 
+const input = [{ a: 2 }, { a: 1 }, { a: 1 }, { a: 3 }]
+
 test('happy', () => {
-  const input = [{ a: 2 }, { a: 1 }, { a: 1 }, { a: 3 }]
   const expected = [{ a: 1 }, { a: 1 }, { a: 2 }, { a: 3 }]
 
   const result = sortBy(x => x.a)(input)
   expect(result).toEqual(expected)
 })
+
+test('with non-existing path', () => {
+	expect(sortBy(x => x.b)(input)).toEqual(input)
+})
 ```
 
 </details>
@@ -9397,6 +9812,215 @@ describe('R.sortBy', () => {
 
 [![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#sortBy)
 
+### sortByDescending
+
+```typescript
+
+sortByDescending<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[]
+```
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+sortByDescending<T>(sortFn: (a: T, b: T) => number): (list: T[]) => T[];
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.sortByDescending</strong> source</summary>
+
+```javascript
+import { sortByFn } from "./sortBy.js";
+
+export function sortByDescending(sortFn) {
+  return list => sortByFn(sortFn, list, true)
+}
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#sortByDescending)
+
+### sortByPath
+
+```typescript
+
+sortByPath<S, K0 extends string & keyof S>(
+  path: [K0]
+): (list: S[]) => S[]
+```
+
+It sorts `list` by the value of `path` property.
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+sortByPath<S, K0 extends string & keyof S>(
+  path: [K0]
+): (list: S[]) => S[];
+sortByPath<S, K0 extends string & keyof S>(
+  path: `${K0}`
+): (list: S[]) => S[];
+sortByPath<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(
+  path: [K0, K1]
+): (list: S[]) => S[];
+sortByPath<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(
+  path: `${K0}.${K1}`
+): (list: S[]) => S[];
+...
+...
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.sortByPath</strong> source</summary>
+
+```javascript
+import { path } from './path.js'
+import { sortBy } from './sortBy.js'
+
+export function sortByPath(sortPath) {
+  return list => sortBy(path(sortPath))(list)
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { sortByPath } from './sortByPath.js'
+
+const list = [{ a: { b: 3 } }, { a: { b: 1 } }, { a: { b: 2 } }]
+const sorted = [{ a: { b: 1 } }, { a: { b: 2 } }, { a: { b: 3 } }]
+
+test('with string as path', () => {
+  expect(sortByPath('a.b')(list)).toEqual(sorted)
+})
+
+test('with list of strings as path', () => {
+  expect(sortByPath(['a', 'b'])(list)).toEqual(sorted)
+})
+
+test('when path is not found in any item', () => {
+	const list = [{ a: { b: 3 } }, { a: { b: 1 } }, { a: {} }]
+	expect(sortByPath('a.b.c.d')(list)).toEqual(list)
+})
+```
+
+</details>
+
+<details>
+
+<summary><strong>TypeScript</strong> test</summary>
+
+```typescript
+import { pipe, sortByPath } from 'rambda'
+
+const input= [{ a: { b: 2 } }, { a: { b: 1 } }]
+
+describe('R.sortByPath', () => {
+  it('with string as path', () => {
+    const result = pipe(input, sortByPath('a.b'))
+		result[0].a.b // $ExpectType number
+  })
+  it('with list of strings as path', () => {
+    const result = pipe(input, sortByPath(['a', 'b']))
+		result[0].a.b // $ExpectType number
+  })
+	it('with non-existent path', () => {
+		// @ts-expect-error
+		pipe(input, sortByPath(['a', 'c']))
+		// @ts-expect-error
+		pipe(input, sortByPath('a.c'))
+	})
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#sortByPath)
+
+### sortByPathDescending
+
+```typescript
+
+sortByPathDescending<S, K0 extends string & keyof S>(
+  path: [K0]
+): (list: S[]) => S[]
+```
+
+<details>
+
+<summary>All TypeScript definitions</summary>
+
+```typescript
+sortByPathDescending<S, K0 extends string & keyof S>(
+  path: [K0]
+): (list: S[]) => S[];
+sortByPathDescending<S, K0 extends string & keyof S>(
+  path: `${K0}`
+): (list: S[]) => S[];
+sortByPathDescending<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(
+  path: [K0, K1]
+): (list: S[]) => S[];
+sortByPathDescending<S, K0 extends string & keyof S, K1 extends string & keyof S[K0]>(
+  path: `${K0}.${K1}`
+): (list: S[]) => S[];
+...
+...
+```
+
+</details>
+
+<details>
+
+<summary><strong>R.sortByPathDescending</strong> source</summary>
+
+```javascript
+import { path } from './path.js'
+import { sortByDescending } from './sortByDescending.js'
+
+export function sortByPathDescending(sortPath) {
+  return list => sortByDescending(path(sortPath))(list)
+}
+```
+
+</details>
+
+<details>
+
+<summary><strong>Tests</strong></summary>
+
+```javascript
+import { sortByPathDescending } from './sortByPathDescending.js'
+
+const list = [{ a: { b: 3 } }, { a: { b: 1 } }, { a: { b: 2 } }]
+const sorted = [{ a: { b: 3 } }, { a: { b: 2 } }, { a: { b: 1 } }]
+
+test('with string as path', () => {
+  expect(sortByPathDescending('a.b')(list)).toEqual(sorted)
+})
+
+test('with list of strings as path', () => {
+  expect(sortByPathDescending(['a', 'b'])(list)).toEqual(sorted)
+})
+```
+
+</details>
+
+[![---------------](https://raw.githubusercontent.com/selfrefactor/rambda/master/files/separator.png)](#sortByPathDescending)
+
 ### sortObject
 
 ```typescript
@@ -11532,7 +12156,7 @@ describe('R.unless', () => {
 
 ```typescript
 
-unwind<S extends string>(prop: S): <T>(obj: T) => Omit<T, S> & { [K in S]: T[S][number] }
+unwind<S extends string>(prop: S): <T>(obj: T) => MergeTypes<Omit<T, S> & { [K in S]: T[S][number] }>
 ```
 
 It takes an object and a property name. The method will return a list of objects, where each object is a shallow copy of the input object, but with the property array unwound.
@@ -11554,7 +12178,7 @@ const expected = [{a:1, b:2}, {a:1, b:3}]
 <summary>All TypeScript definitions</summary>
 
 ```typescript
-unwind<S extends string>(prop: S): <T>(obj: T) => Omit<T, S> & { [K in S]: T[S][number] };
+unwind<S extends string>(prop: S): <T>(obj: T) => MergeTypes<Omit<T, S> & { [K in S]: T[S][number] }>;
 ```
 
 </details>
@@ -11732,7 +12356,7 @@ test('with negative index', () => {
 
 ```typescript
 
-when<T>(predicate: (x: T) => boolean, whenTrueFn: (x: T) => T): (input: T) => T
+when<T, U extends T>(predicate: (x: T) => x is U, whenTrueFn: (x: U) => T): (input: T) => T
 ```
 
 It pass `input` to `predicate` function and if the result is `true`, it will return the result of `whenTrueFn(input)`. 
@@ -11766,6 +12390,7 @@ const expected = [
 <summary>All TypeScript definitions</summary>
 
 ```typescript
+when<T, U extends T>(predicate: (x: T) => x is U, whenTrueFn: (x: U) => T): (input: T) => T;
 when<T>(predicate: (x: T) => boolean, whenTrueFn: (x: T) => T): (input: T) => T;
 when<T, U>(predicate: (x: T) => boolean, whenTrueFn: (x: T) => U): (input: T) => T | U;
 ```
@@ -11813,7 +12438,11 @@ test('happy', () => {
 <summary><strong>TypeScript</strong> test</summary>
 
 ```typescript
-import { pipe, tap, when } from 'rambda'
+import { head, pipe, tap, when } from 'rambda'
+
+function notNull<T>(a: T | null | undefined): a is T {
+  return a != null
+}
 
 describe('R.when', () => {
   it('happy', () => {
@@ -11833,6 +12462,15 @@ describe('R.when', () => {
     )
 
     result // $ExpectType string | number
+  })
+
+	it('with assertion of type', () => {
+    const result = pipe(
+      [1, null, 2, 3],
+      head,
+      when(notNull, x => x + 1),
+    )
+    result // $ExpectType number | null
   })
 })
 ```
@@ -12153,14 +12791,20 @@ This is major revamp of `Rambda` library:
 -- R.rejectObject
 -- R.findNth
 -- R.combinations
--- R.rangeDescending
+-- R.sortByPath
+-- R.sortByPathDescending
+-- R.sortByDescending
+-- R.flattenObject
+-- R.addPropToObjects
 
 - Rename following methods:
 
--- replaceItemAtIndex -> adjust
+-- modifyItemAtIndex -> adjust
 -- checkObjectWithSpec -> where 
 -- objectIncludes -> whereEq
 -- modify -> modifyProp
+-- chain -> flatMap
+-- mapObjIndexed -> mapObject
 
 _ Regarding using object as input with TypeScript in methods such as `R.map/filter` - this feature is no longer supported in TypeScript as it has multiple issues when using inside pipes. In JS, it still works as before. Following methods are affected:
 
@@ -12188,7 +12832,9 @@ _ Regarding using object as input with TypeScript in methods such as `R.map/filt
 
 -- append/prepend
 
-- Change `R.range` to work with `endIndex` included instead of `endIndex` excluded, i.e. `R.range(0, 2)` will return `[0, 1, 2]` instead of `[0, 1]`. This is done because `R.rangeDescending` is added and users would wonder if end or start index is excluded.
+- Change `R.range` to work with descending order.
+
+- Remove `rambda/immutable` as import option as it is hard to support in the new context.
 
 - Sync with typing of `@types/ramda`:
 
@@ -12241,11 +12887,6 @@ _ Regarding using object as input with TypeScript in methods such as `R.map/filt
 
 - Revert adding stopper logic in `R.reduce` - https://github.com/selfrefactor/rambda/pull/630
 
-- Renamed methods: 
-
--- `chain` to `flatMap`
--- `mapObjIndexed` to `mapObject`
-
 9.4.2
 
 - Fix TS issue when `R.take` is used as part of `R.pipe`.