rubico 2.2.3 → 2.3.1

package/dist/x/unless.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/unless.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/values.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.es.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.min.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/dist/x/when.mjs

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/eq.d.ts

@@ -0,0 +1,51 @@
+export = eq;
+/**
+ * @name eq
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * eq(leftValue Promise|any, rightValue Promise|any) -> boolean
+ *
+ * eq(leftValue Promise|any, right function)(...args) -> Promise|boolean
+ * eq(...args, leftValue Promise|any, right function) -> Promise|boolean
+ *
+ * eq(left function, rightValue Promise|any)(...args) -> Promise|boolean
+ * eq(...args, left function, rightValue Promise|any) -> Promise|boolean
+ *
+ * eq(left function, right function)(...args) -> Promise|boolean
+ * eq(...args, left function, right function) -> Promise|boolean
+ * ```
+ *
+ * @description
+ * Test for [equality (`==`)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality) between two values.
+ *
+ * ```javascript [playground]
+ * const areNamesEqual = eq('Ted', 'George')
+ *
+ * console.log(areNamesEqual) // false
+ * ```
+ *
+ * If either of the two values are resolver functions, `eq` returns a function that resolves the values to compare from its arguments.
+ *
+ * ```javascript [playground]
+ * const personIsGeorge = eq(get('name'), 'George')
+ *
+ * const person = { name: 'George', likes: 'bananas' }
+ *
+ * if (personIsGeorge(person)) {
+ *   console.log('The person is george')
+ * }
+ * ```
+ *
+ * `eq` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe({ name: 'George' }, [
+ *   eq('George', get('name')),
+ *   console.log, // true
+ * ])
+ * ```
+ *
+ * @execution concurrent
+ */
+declare const eq: (...args: any[]) => any;

package/es.d.ts

@@ -0,0 +1,80 @@
+export default rubico;
+declare namespace rubico {
+    export { pipe };
+    export { compose };
+    export { tap };
+    export { forEach };
+    export { switchCase };
+    export { tryCatch };
+    export { all };
+    export { assign };
+    export { get };
+    export { set };
+    export { pick };
+    export { omit };
+    export { map };
+    export { filter };
+    export { flatMap };
+    export { reduce };
+    export { transform };
+    export { and };
+    export { or };
+    export { not };
+    export { some };
+    export { every };
+    export { eq };
+    export { gt };
+    export { lt };
+    export { gte };
+    export { lte };
+    export { thunkify };
+    export { always };
+    export { curry };
+    export { __ };
+}
+declare function pipe(...args: any[]): any;
+declare function compose(...args: any[]): any;
+declare function tap(...args: any[]): any;
+declare namespace tap {
+    function _if(predicate: any, func: any): (...args: any[]) => any;
+    export { _if as if };
+}
+declare function forEach(...args: any[]): any;
+declare function switchCase(...args: any[]): any;
+declare function tryCatch(...args: any[]): any;
+declare function all(...args: any[]): any;
+declare namespace all {
+    function series(...args: any[]): any;
+}
+declare function assign(arg0: any, arg1: any): any;
+declare function get(arg0: any, arg1: any, arg2: any): any;
+declare function set(arg0: any, arg1: any, arg2: any): any;
+declare function pick(arg0: any, arg1: any): any;
+declare function omit(arg0: any, arg1: any): any;
+declare function map(...args: any[]): any;
+declare namespace map {
+    function entries(mapper: any): (value: any) => any;
+    function series(mapper: any): (value: any) => any;
+    function pool(concurrencyLimit: any, mapper: any): (value: any) => any[] | Promise<any>;
+}
+declare function filter(...args: any[]): any;
+declare function flatMap(...args: any[]): any;
+declare function reduce(...args: any[]): any;
+declare function transform(...args: any[]): any;
+declare function and(...args: any[]): any;
+declare function or(...args: any[]): any;
+declare function not(...args: any[]): any;
+declare function some(...args: any[]): any;
+declare function every(...args: any[]): any;
+declare function eq(...args: any[]): any;
+declare function gt(...args: any[]): any;
+declare function lt(...args: any[]): any;
+declare function gte(...args: any[]): any;
+declare function lte(...args: any[]): any;
+declare function thunkify(func: any, ...args: any[]): () => any;
+declare function always(value: any): () => any;
+declare function curry(func: any, ...args: any[]): any;
+declare namespace curry {
+    function arity(arity: any, func: any, ...args: any[]): any;
+}
+declare const __: any;

package/es.js

@@ -1,5 +1,5 @@
 /**
- * rubico v2.2.3
+ * rubico v2.3.1
  * https://github.com/a-synchronous/rubico
  * (c) 2019-2023 Richard Tong
  * rubico may be freely distributed under the MIT license.

package/every.d.ts

@@ -0,0 +1,52 @@
+export = every;
+/**
+ * @name every
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Foldable = Array|Iterable|AsyncIterable|{ reduce: function }|Object
+ *
+ * every(collection Foldable, predicate function) -> result Promise|boolean
+ *
+ * every(predicate function)(collection Foldable) -> result Promise|boolean
+ * ```
+ *
+ * @description
+ * Test a predicate concurrently across all items of a collection, returning true if all predications are truthy.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * console.log(
+ *   every([1, 2, 3, 4, 5], isOdd),
+ * ) // false
+ *
+ * console.log(
+ *   every([1, 3, 5], isOdd),
+ * ) // true
+ * ```
+ *
+ * The collection can be any iterable, async iterable, or object values iterable collection. Below is an example of `every` accepting an async generator as the collection.
+ *
+ * ```javascript [playground]
+ * const asyncNumbers = async function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
+ *
+ * every(asyncNumbers(), async number => number < 6).then(console.log) // true
+ * ```
+ *
+ * `every` supports a tacit API for composability.
+ *
+ * ```javascript [playground]
+ * pipe([1, 2, 3], [
+ *   every(number => number < 5),
+ *   console.log, // true
+ * ])
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @muxing
+ */
+declare function every(...args: any[]): any;

package/filter.d.ts

@@ -0,0 +1,148 @@
+export = filter;
+/**
+ * @name filter
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Filterable = Array|Object|Set|Map|Iterator|AsyncIterator
+ *
+ * type Predicate = (
+ *   value any,
+ *   indexOrKey number|string,
+ *   collection Filterable,
+ * )=>boolean
+ *
+ * filter(collection Filterable, predicate Predicate) -> result Promise|Filterable
+ * filter(predicate Predicate)(collection Filterable) -> result Promise|Filterable
+ * ```
+ *
+ * @description
+ * Filter out items from a collection based on the results of their concurrent executions with a synchronous or asynchronous predicate function. `filter` accepts the following collections:
+ *
+ *  * `Array`
+ *  * `Object`
+ *  * `Set`
+ *  * `Map`
+ *  * `Iterator`/`Generator`
+ *  * `AsyncIterator`/`AsyncGenerator`
+ *
+ * For arrays (type `Array`), `filter` applies the predicate function to each item of the array, returning a new array containing only the items that tested truthy by the predicate. The order of the items is preserved. On each iteration, the predicate is passed the item, the index of the item, and a reference to the array.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * console.log(filter(isOdd)(array)) // [1, 3, 5]
+ * console.log(filter(array, isOdd)) // [1, 3, 5]
+ * ```
+ *
+ * For objects (type `Object`), `filter` applies the predicate function to each value of the object, returning a new object containing only the values that tested truthy by the predicate. On each iteration, the predicate is passed the object value, the key of the object value, and a reference to the object.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ *
+ * console.log(filter(isOdd)(obj)) // { a: 1, c: 3, e: 5 }
+ * console.log(filter(obj, isOdd)) // { a: 1, c: 3, e: 5 }
+ * ```
+ *
+ * For sets (type `Set`), `filter` applies the predicate function to each item in the set, returning a new set containing only the items that tested truthy by the predicate. On each iteration, the predicate is passed the item, the same item as the key argument, and a reference to the set.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const set = new Set([1, 2, 3, 4, 5])
+ *
+ * console.log(filter(isOdd)(set)) // Set { 1, 3, 5 }
+ * console.log(filter(set, isOdd)) // Set { 1, 3, 5 }
+ * ```
+ *
+ * For maps (type `Map`), `filter` applies the predicate function to the value of each entry of the map, returning a new map containing only the entries where the values tested truthy by the predicate. The order of the entries are preserved. On each iteration, the predicate is passed the map value, the key of the value, and a reference to the map.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ * const m = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
+ *
+ * console.log(filter(isOdd)(m)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
+ * console.log(filter(m, isOdd)) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
+ * ```
+ *
+ * For iterators (type `Iterator`) or generators (type `Generator`), `filter` returns a lazily filtered iterator/generator; all values that are normally yielded by the iterator/generator that test falsy by the predicate function are skipped by the lazily filtered iterator/generator. On each iteration, the predicate is passed the iteration value only.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const numbersGeneratorFunction = function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
+ *
+ * const numbersGenerator = numbersGeneratorFunction()
+ * const oddNumbersGenerator = filter(numbersGeneratorFunction(), isOdd)
+ * const oddNumbersGenerator2 = filter(isOdd)(numbersGeneratorFunction())
+ *
+ * for (const number of numbersGenerator) {
+ *   console.log(number) // 1
+ *                       // 2
+ *                       // 3
+ *                       // 4
+ *                       // 5
+ * }
+ *
+ * for (const number of oddNumbersGenerator) {
+ *   console.log(number) // 1
+ *                       // 3
+ *                       // 5
+ * }
+ *
+ * for (const number of oddNumbersGenerator2) {
+ *   console.log(number) // 1
+ *                       // 3
+ *                       // 5
+ * }
+ * ```
+ *
+ * With asyncIterators (type `AsyncIterator`) or asyncGenerators (type `AsyncGenerator`), `filter` returns a lazily filtered asyncIterator/asyncGenerator; all values that are normally yielded by the asyncIterator/asyncGenerator that test falsy by the predicate function are skipped by the lazily filtered asyncIterator/asyncGenerator. On each iteration, the predicate is passed the iteration value only.
+ *
+ * ```javascript [playground]
+ * const asyncIsOdd = async number => number % 2 == 1
+ *
+ * const asyncNumbersGeneratorFunction = async function* () {
+ *   yield 1; yield 2; yield 3; yield 4; yield 5
+ * }
+ *
+ * const asyncNumbersGenerator = asyncNumbersGeneratorFunction()
+ *
+ * const asyncOddNumbersGenerator = filter(asyncNumbersGeneratorFunction(), asyncIsOdd)
+ *
+ * const asyncOddNumbersGenerator2 = filter(asyncIsOdd)(asyncNumbersGeneratorFunction())
+ *
+ * for await (const number of asyncNumbersGenerator) {
+ *   console.log(number) // 1
+ *                       // 2
+ *                       // 3
+ *                       // 4
+ *                       // 5
+ * }
+ *
+ * for await (const number of asyncOddNumbersGenerator) {
+ *   console.log(number) // 1
+ *                       // 3
+ *                       // 5
+ * }
+ *
+ * for await (const number of asyncOddNumbersGenerator2) {
+ *   console.log(number) // 1
+ *                       // 3
+ *                       // 5
+ * }
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @transducing
+ */
+declare function filter(...args: any[]): any;

package/flatMap.d.ts

@@ -0,0 +1,109 @@
+export = flatMap;
+/**
+ * @name flatMap
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type FlatMappable = Array|String|Set|Iterator|AsyncIterator
+ *
+ * type Iterable = Iterable|AsyncIterable|Object<value any>
+ *
+ * type FlatMapper = (
+ *   item any,
+ *   indexOrKey string,
+ *   collection FlatMappable
+ * )=>Promise|FlatMappable
+ *
+ * flatMap(collection FlatMappable, flatMapper FlatMapper) -> result Promise|FlatMappable
+ * flatMap(flatMapper FlatMapper)(collection FlatMappable) -> result Promise|FlatMappable
+ * ```
+ *
+ * @description
+ * Applies a flatMapper function concurrently to each item of a collection, creating a new collection of the same type. A flatMapping operation iterates through each item of a collection and applies the flatMapper function to each item, flattening the result of the execution into the result collection. The result of an individual execution can be any iterable, async iterable, or object values iterable collection. The flatMapper function may be asynchronous.
+ *
+ *  * `Iterable` - the execution result is iterated and each item is added to the result collection
+ *  * `AsyncIterable` - the execution result is asynchronously iterated and each item is added to the result collection
+ *  * `Object` - the execution result values are added to the result collection
+ *
+ * The following example demonstrates various execution results being flattened into the same array.
+ *
+ * ```javascript [playground]
+ * const identity = value => value
+ *
+ * flatMap(identity)([
+ *   [1, 1], // array
+ *   new Set([2, 2]), // set
+ *   (function* () { yield 3; yield 3 })(), // generator
+ *   (async function* () { yield 7; yield 7 })(), // asyncGenerator
+ *   { a: 5, b: 5 }, // object
+ *   new Uint8Array([8]), // typedArray
+ * ]).then(console.log)
+ * // [1, 1, 2, 3, 3, 5, 5, 8, 7, 7]
+ * ```
+ *
+ * A flatMapping operation concatenates onto the resulting collection synchronous values and muxes any asynchronous values. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual items.
+ *
+ * ```javascript [playground]
+ * const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
+ *
+ * const repeat3 = function* (message) {
+ *   yield message; yield message; yield message
+ * }
+ *
+ * console.log( // sync is concatenated
+ *   flatMap(['foo', 'bar', 'baz'], repeat3),
+ * ) // ['foo', 'foo', 'foo', 'bar', 'bar', 'bar', 'baz', 'baz', 'baz']
+ *
+ * const asyncRepeat3 = async function* (message) {
+ *   yield message
+ *   await sleep(100)
+ *   yield message
+ *   await sleep(1000)
+ *   yield message
+ * }
+ *
+ * // async is muxed
+ * flatMap(['foo', 'bar', 'baz'], asyncRepeat3).then(console.log)
+ * // ['foo', 'bar', 'baz', 'foo', 'bar', 'baz', 'foo', 'bar', 'baz']
+ * ```
+ *
+ * For arrays (type `Array`), `flatMap` applies the flatMapper function to each item, pushing (`.push`) the items of each execution into a new array.
+ *
+ * ```javascript [playground]
+ * const duplicate = value => [value, value]
+ *
+ * console.log(
+ *   flatMap([1, 2, 3, 4, 5], duplicate)
+ * ) // [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
+ * ```
+ *
+ * For strings (type `String`), `flatMap` applies the flatMapper function to each character, adding (`+`) the items of each execution into a new string
+ *
+ * ```javascript [playground]
+ * const duplicate = value => [value, value]
+ *
+ * console.log(
+ *   flatMap('12345', duplicate)
+ * ) // 1122334455
+ * ```
+ *
+ * For sets (type `Set`), `flatMap` applies the flatMapper function to each item, adding (`.add`) the items of each execution into a new set
+ *
+ * ```javascript [playground]
+ * const pairPlus100 = value => [value, value + 100]
+ *
+ * console.log(
+ *   flatMap(new Set([1, 2, 3, 4, 5]), pairPlus100)
+ * ) // Set(10) { 1, 101, 2, 102, 3, 103, 4, 104, 5, 105 }
+ * ```
+ *
+ * @execution concurrent
+ *
+ * @transducing
+ *
+ * @archive
+ *  * For typed arrays (type [`TypedArray`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#typedarray_objects)) and Node.js buffers (type [`Buffer`](https://nodejs.org/api/buffer.html)), `flatMap` applies a flatMapper function to each value of the typed array/buffer, joining the result of each execution with `.set` into the resulting typed array
+ *
+ *  * For Node.js duplex streams (type [Stream](https://nodejs.org/api/stream.html#class-streamduplex)), `flatMap` applies a flatMapper function to each item of the stream, writing (`.write`) each item of each execution into the duplex stream
+ */
+declare function flatMap(...args: any[]): any;

package/forEach.d.ts

@@ -0,0 +1,35 @@
+export = forEach;
+/**
+ * @name forEach
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Collection = Array|Iterable|AsyncIterable|{ forEach: function }|Object
+ *
+ * forEach(collection Collection, callback function) -> collection Collection
+ *
+ * forEach(callback function)(collection Collection) -> collection Collection
+ * ```
+ *
+ * @description
+ * Execute a callback for each item of a collection, returning a Promise if the execution is asynchronous.
+ *
+ * ```javascript [playground]
+ * forEach([1, 2, 3, 4, 5l], console.log) // 1 2 3 4 5
+ *
+ * forEach({ a: 1, b: 2, c: 3 }, console.log) // 1 2 3
+ * ```
+ *
+ * Omit the data argument for a composable API
+ *
+ * ```javascript [playground]
+ * pipe([1, 2, 3, 4, 5], [
+ *   filter(number => number % 2 == 1),
+ *   map(number => number ** 2),
+ *   forEach(console.log), // 1
+ *                         // 9
+ *                         // 25
+ * ])
+ * ```
+ */
+declare function forEach(...args: any[]): any;

package/get.d.ts

@@ -0,0 +1,70 @@
+export = get;
+/**
+ * @name get
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * get(
+ *   object Promise|Object,
+ *   path string|number|Array<string|number>,
+ *   defaultValue? function|any
+ * ) -> result Promise|Object
+ *
+ * get(
+ *   path string|number|Array<string|number>,
+ *   defaultValue? function|any
+ * )(object Object) -> result Promise|Object
+ * ```
+ *
+ * @description
+ * Accesses a property of an object given a path denoted by a string, number, or an array of string or numbers.
+ *
+ * ```javascript [playground]
+ * const obj = { hello: 'world' }
+ *
+ * console.log(get(obj, 'hello')) // world
+ * ```
+ *
+ * `get` supports a tacit API for composability
+ *
+ * ```javascript [playground]
+ * const obj = { hello: 'world' }
+ *
+ * const getHello = get('hello')
+ *
+ * console.log(getHello({ hello: 'world' })) // world
+ * ```
+ *
+ * If the value at the end of the path is not found on the object, returns an optional default value. The default value can be a function resolver that takes the object as an argument. If no default value is provided, returns `undefined`. The function resolver may be asynchronous (returns a promise).
+ *
+ * ```javascript [playground]
+ * const getHelloWithDefaultValue = get('hello', 'default')
+ *
+ * console.log(getHelloWithDefaultValue({ foo: 'bar' })) // default
+ *
+ * const getHelloWithDefaultResolver = get('hello', object => object.foo)
+ *
+ * console.log(getHelloWithDefaultResolver({ foo: 'bar' })) // bar
+ * ```
+ *
+ * `get` supports three types of path patterns for nested property access.
+ *
+ *  * dot delimited - `'a.b.c'`
+ *  * bracket notation - `'a[0].value'`
+ *  * an array of keys or indices - `['a', 0, 'value']`
+ *
+ * ```javascript [playground]
+ * const getABC0 = get('a.b.c[0]')
+ *
+ * console.log(getABC0({ a: { b: { c: ['hello'] } } })) // hello
+ *
+ * const get00000DotNotation = get('0.0.0.0.0')
+ * const get00000BracketNotation = get('[0][0][0][0][0]')
+ * const get00000ArrayNotation = get([0, 0, 0, 0, 0])
+ *
+ * console.log(get00000DotNotation([[[[['foo']]]]])) // foo
+ * console.log(get00000BracketNotation([[[[['foo']]]]])) // foo
+ * console.log(get00000ArrayNotation([[[[['foo']]]]])) // foo
+ * ```
+ */
+declare function get(arg0: any, arg1: any, arg2: any): any;

package/global.d.ts

@@ -0,0 +1 @@
+export {};