Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.
Awesome Lists | Featured Topics | Projects
https://github.com/metarhia/common

Metarhia Common Library 🗜️
https://github.com/metarhia/common
array callback cluster common curry date eventemitter functional-programming globalstorage impress javascript js jstp metarhia node nodejs server strings tools utilities
Last synced: 2 days ago
JSON representation
Metarhia Common Library 🗜️
Host: GitHub
URL: https://github.com/metarhia/common
Owner: metarhia
License: mit
Created: 2017-03-04T17:54:15.000Z (over 7 years ago)
Default Branch: master
Last Pushed: 2023-10-19T11:09:49.000Z (about 1 year ago)
Last Synced: 2024-11-06T01:42:46.072Z (9 days ago)
Topics: array, callback, cluster, common, curry, date, eventemitter, functional-programming, globalstorage, impress, javascript, js, jstp, metarhia, node, nodejs, server, strings, tools, utilities
Language: JavaScript
Homepage: https://metarhia.com
Size: 1.44 MB
Stars: 63
Watchers: 19
Forks: 34
Open Issues: 28
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Funding: .github/FUNDING.yml
- License: LICENSE
- Authors: AUTHORS
Awesome Lists containing this project

README

        # Metarhia Common Library

[![ci status](https://github.com/metarhia/common/workflows/Testing%20CI/badge.svg)](https://github.com/metarhia/common/actions?query=workflow%3A%22Testing+CI%22+branch%3Amaster)

[![snyk](https://snyk.io/test/github/metarhia/common/badge.svg)](https://snyk.io/test/github/metarhia/common)

[![npm version](https://badge.fury.io/js/%40metarhia%2Fcommon.svg)](https://badge.fury.io/js/%40metarhia%2Fcommon)

[![npm downloads/month](https://img.shields.io/npm/dm/@metarhia/common.svg)](https://www.npmjs.com/package/@metarhia/common)

[![npm downloads](https://img.shields.io/npm/dt/@metarhia/common.svg)](https://www.npmjs.com/package/@metarhia/common)

[![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/metarhia/common/blob/master/LICENSE)

## Installation

```bash

$ npm install @metarhia/common

```

## API

- [splitAt](#splitatindex-array)

- [shuffle](#shufflearr)

- [sample](#samplearr)

- [range](#rangefrom-to)

- [sequence](#sequenceseq-max)

- [last](#lastarr)

- [pushSame](#pushsamearr-n-value)

- [checkLogin](#checkloginlogin-required-optional)

- [checkPassword](#checkpasswordpassword-required-optional)

- [checkLoginPassword](#checkloginpasswordlogin-password-required-optional)

- [BTree](#class-btree)

  - [BTree.prototype.constructor](#btreeprototypeconstructordegree--default_degree)

  - [BTree.prototype.get](#btreeprototypegetkey)

  - [BTree.prototype.iterator](#btreeprototypeiteratorstart-finish)

  - [BTree.prototype.remove](#btreeprototyperemovekey)

  - [BTree.prototype.set](#btreeprototypesetkey-data)

- [cache](#cache)

- [Cache](#class-cache-extends-map)

  - [Cache.prototype.constructor](#cacheprototypeconstructor)

  - [Cache.prototype.add](#cacheprototypeaddkey-val)

  - [Cache.prototype.clr](#cacheprototypeclrprefix-fn)

  - [Cache.prototype.del](#cacheprototypedelkey)

- [falseness](#falseness)

- [trueness](#trueness)

- [emptiness](#emptiness)

- [nop](#nopcallback)

- [noop](#noopempty-callback)

- [once](#oncefn)

- [unsafeCallback](#unsafecallbackargs)

- [safeCallback](#safecallbackargs)

- [requiredCallback](#requiredcallbackargs)

- [onceCallback](#oncecallbackargs)

- [safeFunction](#safefunctionfn)

- [unsafeFunction](#unsafefunctionfn)

- [id](#idx)

- [asyncId](#asyncidx-callback)

- [isScalar](#isscalarvalue)

- [copy](#copyds)

- [clone](#cloneobj)

- [duplicate](#duplicateobj)

- [getByPath](#getbypathdata-datapath)

- [setByPath](#setbypathdata-datapath-value)

- [deleteByPath](#deletebypathdata-datapath)

- [merge](#mergeargs)

- [mergeObjects](#mergeobjectsmerger-objs)

- [Enum](#class-enum)

  - [Enum.from](#enumfromargs)

  - [Enum.prototype.constructor](#enumprototypeconstructor)

- [forwardEvents](#forwardeventsfrom-to-events)

- [emitter](#emitter)

- [EnhancedEmitter](#class-enhancedemitter-extends-eventemitter)

  - [EnhancedEmitter.prototype.constructor](#enhancedemitterprototypeconstructor)

  - [EnhancedEmitter.prototype.emit](#enhancedemitterprototypeemitargs)

  - [EnhancedEmitter.prototype.forward](#enhancedemitterprototypeforwardto-events)

- [Flags](#class-flags)

  - [Flags.from](#flagsfromargs)

  - [Flags.prototype.constructor](#flagsprototypeconstructorargs)

- [partial](#partialfn-args)

- [omap](#omapmapfn-obj)

- [compose](#composefns)

- [maybe](#maybefn-defval-value)

- [zip](#ziparrays)

- [replicate](#replicatecount-elem)

- [zipWith](#zipwithfn-arrays)

- [curryUntil](#curryuntilcondition-fn-args)

- [curryN](#currynfn-count-args)

- [curryTwice](#currytwicefn)

- [curry](#curryfn-param)

- [applyArgs](#applyargsargs)

- [either](#eitherfn)

- [restLeft](#restleftfn)

- [mkdirp](#mkdirpdir-mode-cb)

- [mkdirpPromise](#mkdirppromisedir-mode--mkdirp_default_mode)

- [rmdirp](#rmdirpdir-cb)

- [rmRecursive](#rmrecursivepath-callback)

- [rmRecursivePromise](#async-rmrecursivepromisepath)

- [generateKey](#generatekeylength-possible)

- [generateGUID](#generateguid)

- [generateToken](#generatetokensecret-characters-length)

- [crcToken](#crctokensecret-key)

- [validateToken](#validatetokensecret-token)

- [hash](#hashpassword-salt)

- [validateHash](#validatehashhashvalue-password-salt)

- [generateStorageKey](#generatestoragekey)

- [idToChunks](#idtochunksid)

- [idToPath](#idtopathid)

- [pathToId](#pathtoidpath)

- [Int64](#class-int64)

  - [Int64.add](#int64adda-b)

  - [Int64.and](#int64anda-b)

  - [Int64.cmp](#int64cmpa-b)

  - [Int64.div](#int64diva-b)

  - [Int64.mod](#int64moda-b)

  - [Int64.mult](#int64multa-b)

  - [Int64.not](#int64nota)

  - [Int64.one](#int64one)

  - [Int64.or](#int64ora-b)

  - [Int64.shiftLeft](#int64shiftlefta-b)

  - [Int64.shiftRight](#int64shiftrighta-b)

  - [Int64.sub](#int64suba-b)

  - [Int64.xor](#int64xora-b)

  - [Int64.zero](#int64zero)

  - [Int64.prototype.constructor](#int64prototypeconstructorvalue)

  - [Int64.prototype.add](#int64prototypeaddb)

  - [Int64.prototype.and](#int64prototypeandb)

  - [Int64.prototype.dec](#int64prototypedec)

  - [Int64.prototype.inc](#int64prototypeinc)

  - [Int64.prototype.not](#int64prototypenot)

  - [Int64.prototype.or](#int64prototypeorb)

  - [Int64.prototype.shiftLeft](#int64prototypeshiftleftb)

  - [Int64.prototype.shiftRight](#int64prototypeshiftrightb)

  - [Int64.prototype.shiftRightArithmetic](#int64prototypeshiftrightarithmeticb)

  - [Int64.prototype.shiftRightLogical](#int64prototypeshiftrightlogicalb)

  - [Int64.prototype.sub](#int64prototypesubb)

  - [Int64.prototype.toInt32](#int64prototypetoint32)

  - [Int64.prototype.toJSON](#int64prototypetojson)

  - [Int64.prototype.toPostgres](#int64prototypetopostgres)

  - [Int64.prototype.toString](#int64prototypetostringradix--10)

  - [Int64.prototype.toUint32](#int64prototypetouint32)

  - [Int64.prototype.xor](#int64prototypexorb)

- [Iterator](#class-iterator)

  - [Iterator.indices](#iteratorindicesarr)

  - [Iterator.range](#iteratorrangestart-stop-step)

  - [Iterator.zip](#iteratorzipiterators)

  - [Iterator.prototype.constructor](#iteratorprototypeconstructorbase)

  - [Iterator.prototype.apply](#iteratorprototypeapplyfn)

  - [Iterator.prototype.chain](#iteratorprototypechainiterators)

  - [Iterator.prototype.chainApply](#iteratorprototypechainapplyfn)

  - [Iterator.prototype.collectTo](#iteratorprototypecollecttocollectionclass)

  - [Iterator.prototype.collectWith](#iteratorprototypecollectwithobj-collector)

  - [Iterator.prototype.count](#iteratorprototypecount)

  - [Iterator.prototype.each](#iteratorprototypeeachfn-thisarg)

  - [Iterator.prototype.enumerate](#iteratorprototypeenumerate)

  - [Iterator.prototype.every](#iteratorprototypeeverypredicate-thisarg)

  - [Iterator.prototype.filter](#iteratorprototypefilterpredicate-thisarg)

  - [Iterator.prototype.filterMap](#iteratorprototypefiltermapmapper-thisarg-filtervalue)

  - [Iterator.prototype.find](#iteratorprototypefindpredicate-thisarg)

  - [Iterator.prototype.findCompare](#iteratorprototypefindcomparecomparator-accessor-thisarg)

  - [Iterator.prototype.firstNonNullable](#iteratorprototypefirstnonnullabledefaultvalue)

  - [Iterator.prototype.flat](#iteratorprototypeflatdepth--1)

  - [Iterator.prototype.flatMap](#iteratorprototypeflatmapmapper-thisarg)

  - [Iterator.prototype.forEach](#iteratorprototypeforeachfn-thisarg)

  - [Iterator.prototype.groupBy](#iteratorprototypegroupbyclassifier-thisarg)

  - [Iterator.prototype.includes](#iteratorprototypeincludeselement)

  - [Iterator.prototype.join](#iteratorprototypejoinsep----prefix---suffix--)

  - [Iterator.prototype.last](#iteratorprototypelastdefaultvalue)

  - [Iterator.prototype.map](#iteratorprototypemapmapper-thisarg)

  - [Iterator.prototype.max](#iteratorprototypemaxaccessor-thisarg)

  - [Iterator.prototype.min](#iteratorprototypeminaccessor-thisarg)

  - [Iterator.prototype.next](#iteratorprototypenext)

  - [Iterator.prototype.partition](#iteratorprototypepartitionpredicate-thisarg)

  - [Iterator.prototype.reduce](#iteratorprototypereducereducer-initialvalue)

  - [Iterator.prototype.skip](#iteratorprototypeskipamount)

  - [Iterator.prototype.skipWhile](#iteratorprototypeskipwhilepredicate-thisarg)

  - [Iterator.prototype.some](#iteratorprototypesomepredicate-thisarg)

  - [Iterator.prototype.someCount](#iteratorprototypesomecountpredicate-count-thisarg)

  - [Iterator.prototype.take](#iteratorprototypetakeamount)

  - [Iterator.prototype.takeWhile](#iteratorprototypetakewhilepredicate-thisarg)

  - [Iterator.prototype.toArray](#iteratorprototypetoarray)

  - [Iterator.prototype.toObject](#iteratorprototypetoobject)

  - [Iterator.prototype.zip](#iteratorprototypezipiterators)

- [iter](#iterbase)

- [iterEntries](#iterentriesobj)

- [iterKeys](#iterkeysobj)

- [iterValues](#itervaluesobj)

- [cryptoPrefetcher](#cryptoprefetcherbufsize-valuesize)

- [random](#randommin-max)

- [cryptoRandom](#cryptorandom)

- [methods](#methodsiface)

- [properties](#propertiesiface)

- [ipToInt](#iptointip)

- [localIPs](#localips)

- [parseHost](#parsehosthost)

- [override](#overrideobj-fn)

- [mixin](#mixintarget-source)

- [Pool](#class-pool)

  - [Pool.prototype.constructor](#poolprototypeconstructorfactory--null)

  - [Pool.prototype.get](#poolprototypeget)

  - [Pool.prototype.put](#poolprototypeputvalue)

- [sortComparePriority](#sortcompareprioritypriority-s1-s2)

- [sortCompareDirectories](#sortcomparedirectoriesa-b)

- [sortCompareByName](#sortcomparebynamea-b)

- [MemoryWritable](#class-memorywritable-extends-writable)

  - [MemoryWritable.prototype.constructor](#memorywritableprototypeconstructorsizelimit)

  - [MemoryWritable.prototype.getData](#async-memorywritableprototypegetdataencoding)

- [subst](#substtpl-data-datapath-escapehtml)

- [htmlEscape](#htmlescapecontent)

- [fileExt](#fileextfilename)

- [removeExt](#removeextfilename)

- [spinalToCamel](#spinaltocamelname)

- [escapeRegExp](#escaperegexps)

- [newEscapedRegExp](#newescapedregexps)

- [addTrailingSlash](#addtrailingslashs)

- [stripTrailingSlash](#striptrailingslashs)

- [dirname](#dirnamefilepath)

- [capitalize](#capitalizes)

- [between](#betweens-prefix-suffix)

- [removeBOM](#removeboms)

- [arrayRegExp](#arrayregexpitems)

- [section](#sections-separator)

- [rsection](#rsections-separator)

- [split](#splits-separator-limit)

- [rsplit](#rsplits-separator-limit)

- [normalizeEmail](#normalizeemailemail)

- [isTimeEqual](#istimeequaltime1-time2)

- [nowDate](#nowdatedate)

- [nowDateTime](#nowdatetimedate)

- [Uint64](#class-uint64)

  - [Uint64.add](#uint64adda-b)

  - [Uint64.and](#uint64anda-b)

  - [Uint64.cmp](#uint64cmpa-b)

  - [Uint64.div](#uint64diva-b)

  - [Uint64.mod](#uint64moda-b)

  - [Uint64.mult](#uint64multa-b)

  - [Uint64.not](#uint64nota)

  - [Uint64.or](#uint64ora-b)

  - [Uint64.shiftLeft](#uint64shiftlefta-b)

  - [Uint64.shiftRight](#uint64shiftrighta-b)

  - [Uint64.sub](#uint64suba-b)

  - [Uint64.xor](#uint64xora-b)

  - [Uint64.prototype.constructor](#uint64prototypeconstructorvalue)

  - [Uint64.prototype.add](#uint64prototypeaddb)

  - [Uint64.prototype.and](#uint64prototypeandb)

  - [Uint64.prototype.dec](#uint64prototypedec)

  - [Uint64.prototype.inc](#uint64prototypeinc)

  - [Uint64.prototype.not](#uint64prototypenot)

  - [Uint64.prototype.or](#uint64prototypeorb)

  - [Uint64.prototype.shiftLeft](#uint64prototypeshiftleftb)

  - [Uint64.prototype.shiftRight](#uint64prototypeshiftrightb)

  - [Uint64.prototype.sub](#uint64prototypesubb)

  - [Uint64.prototype.toJSON](#uint64prototypetojson)

  - [Uint64.prototype.toPostgres](#uint64prototypetopostgres)

  - [Uint64.prototype.toString](#uint64prototypetostringradix--10)

  - [Uint64.prototype.toUint32](#uint64prototypetouint32)

  - [Uint64.prototype.xor](#uint64prototypexorb)

- [duration](#durations)

- [durationToString](#durationtostringn)

- [bytesToSize](#bytestosizebytes)

- [sizeToBytes](#sizetobytessize)

- [safe](#safefn)

- [captureMaxStack](#capturemaxstack)

- [callerFilename](#callerfilenamedepth--0-stack--null)

- [callerFilepath](#callerfilepathdepth--0-stack--null)

### splitAt(index, array)

- `index`: [``][number] index defining end of first part and start of

  second

- `array`: [``][array] to be split

_Returns:_ [``][array] tuple with two parts of the array

Split array into two parts

### shuffle(arr)

- `arr`: [``][array]

_Returns:_ [``][array]

Shuffle an array

### sample(arr)

- `arr`: [``][array]

_Returns:_ ``

Random element from array

### range(from, to)

- `from`: [``][number] range start

- `to`: [``][number] range end

_Returns:_ [``][array]

Generate int array from given range

_Example:_

```js

range(1, 5);

```

_Result:_

```js

[1, 2, 3, 4, 5];

```

### sequence(seq\[, max\])

- `seq`: [``][array]

- `max`: [``][number] (optional), max

_Returns:_ [``][array]

Generate int array from sequence syntax

_Example:_

```js

list: sequence([81, 82, 83]);

```

_Result:_

```js

[81, 82, 83];

```

_Example:_

```js

range from..to: sequence([81,,83]) = [81, 82, 83];

```

_Result:_

```js

[81, 82, 83];

```

_Example:_

```js

range from..count: sequence([81, [3]]) = [81, 82, 83];

```

_Result:_

```js

[81, 82, 83];

```

_Example:_

```js

range from..max-to: sequence([81, [-2]], 5) = [81, 82, 83];

```

_Result:_

```js

[81, 82, 83];

```

### last(arr)

- `arr`: [``][array]

_Returns:_ `` element

Get last element of array

### pushSame(arr, n, value)

- `arr`: [``][array]

- `n`: [``][number]

- `value`: ``

_Returns:_ [``][number] new value of arr.length

Push single value multiple times

### checkLogin(login, required\[, optional\])

- `login`: [``][string] login to test

- `required`: [``][array] required tests configs

- `optional`: [``][array] optional tests configs, defalult: `[]`

_Returns:_ ``

Function that tests the login

### checkPassword(password, required\[, optional\])

- `password`: [``][string] password to test

- `required`: [``][array] required tests configs

- `optional`: [``][array] optional tests configs, default: `[]`

_Returns:_ ``

Function that tests the password

### checkLoginPassword(login, password, required\[, optional\])

- `login`: [``][string] login to test

- `password`: [``][string] password to test

- `required`: [``][array] required tests configs

- `optional`: [``][array] optional tests configs, default: `[]`

_Returns:_ ``

Function that tests the login with password

### class BTree

#### BTree.prototype.constructor(degree = DEFAULT\_DEGREE)

#### BTree.prototype.get(key)

#### BTree.prototype.iterator(start, finish)

#### BTree.prototype.remove(key)

#### BTree.prototype.set(key, data)

### cache()

_Returns:_ ``

Create Cache, enhanced Map

### class Cache extends [Map][map]

#### Cache.prototype.constructor()

#### Cache.prototype.add(key, val)

- `key`: [``][string] key

- `val`: `` associated value

Add key-value pair to cache

#### Cache.prototype.clr(prefix\[, fn\])

- `prefix`: [``][string] to compare with beginning of the key

- `fn`: [``][function] (optional)

  - `key`: [``][string] key

  - `val`: `` associative value to be called on each key

Clear cache elements that start with prefix

#### Cache.prototype.del(key)

- `key`: [``][string] key

Delete cache element

### falseness()

_Returns:_ [``][boolean] always `false`

Empty function

### trueness()

_Returns:_ [``][boolean] always `true`

Empty function

### emptiness()

Empty function

### nop(callback)

- `callback`: [``][function] callback to be called with (null)

Empty asynchronous callback-last single-argument function

### noop(empty, callback)

- `empty`: `` incoming value to be ignored

- `callback`: [``][function] callback to be called with (null, null)

Empty asynchronous callback-last double-argument function

### once(\[fn\])

- `fn`: [``][function] (optional)

_Returns:_ [``][function] function(...args) wrapped callback

- `args`: [``][array]

Wrap function: call once, not null

### unsafeCallback(args)

- `args`: [``][array] arguments

_Returns:_ [``][function]|[``][null] callback if any

Extract callback function

It's unsafe: may return null, allows multiple calls

### safeCallback(args)

- `args`: [``][array] arguments

_Returns:_ [``][function] callback or common.emptiness if there is no

callback

Extract callback

### requiredCallback(args)

- `args`: [``][array] arguments

_Returns:_ [``][function] extracted callback

Extract callback

_Throws:_ [``][typeerror] if there is no callback

### onceCallback(args)

- `args`: [``][array] arguments

_Returns:_ [``][function] callback or common.emptiness if there is no

callback

Extract callback and make it safe

Wrap callback with once()

### safeFunction(fn)

- `fn`: [``][function]

_Returns:_ [``][function] function or `common.emptiness` if fn is not

a function

Check function and make it safe

### unsafeFunction(fn)

- `fn`: [``][function]

_Returns:_ [``][function]|[``][null] function or null if fn is

not a function

Check function

### id(x)

- `x`: `` incoming value which will be returned

_Returns:_ `` incoming value

Identity function

### asyncId(x, callback)

- `x`: `` incoming value which will be returned into the callback

- `callback`: [``][function] callback to be called with first argument

  - `err`: [``][null]

  - `data`: ``

Async identity function

### isScalar(value)

- `value`: ``

_Returns:_ [``][boolean]

Check if value is scalar

### copy(ds)

- `ds`: [``][object] source dataset to be copied

_Returns:_ [``][object]

Copy dataset (copy objects to new array)

### clone(obj)

- `obj`: [``][object]|[``][array]

_Returns:_ [``][object]|[``][array]

Clone object or array

### duplicate(obj)

- `obj`: [``][object]|[``][array]

_Returns:_ [``][object]|[``][array]

Duplicate object or array (properly handles prototype and circular links)

### getByPath(data, dataPath)

- `data`: [``][object]

- `dataPath`: [``][string] dot-separated path

_Returns:_ `` value

Read property by dot-separated path

### setByPath(data, dataPath, value)

- `data`: [``][object]

- `dataPath`: [``][string] dot-separated path

- `value`: `` new value

Set property by dot-separated path

### deleteByPath(data, dataPath)

- `data`: [``][object]

- `dataPath`: [``][string] dot-separated path

_Returns:_ [``][boolean]

Delete property by dot-separated path

### merge(...args)

- `args`: [``][array] arrays with elements to be merged

_Returns:_ [``][array]

Distinctly merge multiple arrays

### mergeObjects(merger, ...objs)

- `merger`: [``][function]

  - `key`: [``][string] current merging key

  - `...values`: `` values under key

- `objs`: [``][object] objects to be merged

_Returns:_ [``][object]

Merge multiple objects with merger

### class Enum

#### Enum.NaE

- `` Not an Enum

#### Enum.from(...args)

#### Enum.prototype.constructor()

### forwardEvents(from, to\[, events\])

- `from`: [``][eventemitter] to listen for event

- `to`: [``][eventemitter] to emit event on

- `events`: [``][string]|[``][object]|[``][string]

  (optional), events names

Forward events from one EventEmitter to another

_Example:_

```js

forwardEvents(from, to);

```

_Example:_

```js

forwardEvents(from, to, 'eventName');

```

_Example:_

```js

forwardEvents(from, to, { eventName: 'newEventName' });

```

_Example:_

```js

forwardEvents(from, to, ['eventName1', 'eventName2']);

```

### emitter()

_Returns:_ [``][eventemitter]

Create EnhancedEmitter, enhanced EventEmitter

with wildcard and forward method

### class EnhancedEmitter extends [EventEmitter][eventemitter]

#### EnhancedEmitter.prototype.constructor()

#### EnhancedEmitter.prototype.emit(...args)

- `args`: [``][array] arguments to be passed

Call listener with provided arguments

#### EnhancedEmitter.prototype.forward(to, events)

- `to`: [``][eventemitter] to emit event on

- `events`: [``][string]|[``][object]|[``][string]

  events names

Forward events from one EventEmitter to another

### class Flags

#### Flags.from(...args)

#### Flags.prototype.constructor(...args)

### partial(fn, ...args)

- `fn`: [``][function]

- `args`: [``][array] arguments to be applied

_Returns:_ [``][function] function(...rest)

- `rest`: [``][array] arguments

Partially apply arguments to function

### omap(mapFn, obj)

- `mapFn`: [``][function] to apply to every field value

- `obj`: [``][object] which fields used for mapping

_Returns:_ [``][object] with same reference but with transformed fields

Map object fields with provided function

### compose(...fns)

- `fns`: [``][array] functions to be composed

_Returns:_ [``][function] function(...args), composed

- `args`: [``][array] arguments to be passed to the first function

Compose multiple functions into one

### maybe(fn, defVal\[, value\])

- `fn`: [``][function]

- `defVal`: `` default value

- `value`: `` (optional), value

_Returns:_ `` result of `fn` or `defVal`

Apply given function to value or default value

### zip(...arrays)

- `arrays`: [``][array] arrays to be zipped

_Returns:_ [``][array] length is minimal of input arrays length, element

with index i of resulting array is array with elements with index i from input

array

Zip several arrays into one

### replicate(count, elem)

- `count`: [``][number] new array length

- `elem`: `` value to replicate

_Returns:_ [``][array] replicated

Create array of replicated values

### zipWith(fn, ...arrays)

- `fn`: [``][function] for zipping elements with index i

- `arrays`: [``][array] arrays to be zipped

_Returns:_ [``][array] zipped, element with index i of resulting array is

result of fn called with arguments from arrays

Zip arrays using specific function

### curryUntil(condition, fn, ...args)

- `condition`: [``][function] returns: [``][boolean]

  - `argsI`: [``][array] arguments for i-th currying

  - `argsParts`: [``][array] of args given for currying from first to

    i-th currying

- `fn`: [``][function] to be curried

- `args`: [``][array] arguments for fn

_Returns:_ [``][function] function(...args), curried

- `args`: [``][array] arguments

Curry function until the condition is met

### curryN(fn, count, ...args)

- `fn`: [``][function] to be curried

- `count`: [``][number] of times function should be curried

- `args`: [``][array] arguments for first currying

_Returns:_ [``][function] curried given times count

Curry fn count times, first curry uses args for first currying

### curryTwice(fn)

- `fn`: [``][function] to be curried

_Returns:_ [``][function] to pass arguments that returns curried fn

Curry function curry with fn

### curry(fn, ...param)

- `fn`: [``][function] to be curried

- `param`: [``][array] arguments to the function

_Returns:_ [``][function] function(...args), curried

Curry function with given arguments

### applyArgs(...args)

- `args`: [``][array] arguments to save in closure

_Returns:_ [``][function] returns: ``, result of `fn(...args)`

- `fn`: [``][function] to be applied saved arguments

Apply arguments

### either(fn)

- `fn`: [``][function] to be called

_Returns:_ [``][function] function(...args), returns: ``, result

of `fn(arg)`, where `arg` - first valid element of `args`

- `args`: [``][array] arguments to iterate

Get first not errored result of fn

_Throws:_ [``][error] if `fn` throws it

### restLeft(fn)

- `fn`: [``][function] function(args, ...namedArgs, callback)

  - `args`: [``][array] rest of spreadArgs created by excluding namedArgs

  - `namedArgs`: [``][array] first values of spreadArgs, length is based

    upon interface of fn

  - `callback`: [``][function] callback, last argument of spreadArgs

_Returns:_ [``][function] function(...spreadArgs)

- `spreadArgs`: [``][array] arguments to be added

Rest left, transform function

### mkdirp(dir, mode, cb)

### mkdirpPromise(dir, mode = MKDIRP\_DEFAULT\_MODE)

### rmdirp(dir, cb)

### rmRecursive(path, callback)

- `path`: [``][string] path to a file or directory to be removed

- `callback`: [``][function] callback

Recursively remove directory

### async rmRecursivePromise(path)

- `path`: [``][string] path to a file or directory to be removed

_Returns:_ [``][promise]

Recursively remove directory

### generateKey(length, possible)

- `length`: [``][number] key length

- `possible`: [``][string] with possible characters

_Returns:_ [``][string] key

Generate random key

### generateGUID()

_Returns:_ [``][string] GUID

Generate an RFC4122-compliant GUID (UUID v4)

### generateToken(secret, characters, length)

- `secret`: [``][string]

- `characters`: [``][string]

- `length`: [``][number]

_Returns:_ [``][string] token

Generate random Token

### crcToken(secret, key)

- `secret`: [``][string]

- `key`: [``][string]

_Returns:_ [``][string] crc

Calculate Token crc

### validateToken(secret, token)

- `secret`: [``][string]

- `token`: [``][string]

_Returns:_ [``][boolean]

Validate Token

### hash(password, salt)

- `password`: [``][string]

- `salt`: [``][string]

_Returns:_ [``][string] hash

Calculate hash with salt

### validateHash(hashValue, password, salt)

- `hashValue`: [``][string]

- `password`: [``][string]

- `salt`: [``][string]

_Returns:_ [``][boolean]

Validate hash

### generateStorageKey()

_Returns:_ [``][string] [folder1, folder2, code]

Generate file storage key

### idToChunks(id)

- `id`: [``][number]

_Returns:_ [``][array] minimal length is 2 which contains hex strings

with length of 4

Convert id to array of hex strings

### idToPath(id)

- `id`: [``][number]

_Returns:_ [``][string]

Convert id to file path

### pathToId(path)

- `path`: [``][string]

_Returns:_ [``][number]

Convert file path to id

### class Int64

#### Int64.add(a, b)

#### Int64.and(a, b)

#### Int64.cmp(a, b)

#### Int64.div(a, b)

#### Int64.mod(a, b)

#### Int64.mult(a, b)

#### Int64.not(a)

#### Int64.one()

#### Int64.or(a, b)

#### Int64.shiftLeft(a, b)

#### Int64.shiftRight(a, b)

#### Int64.sub(a, b)

#### Int64.xor(a, b)

#### Int64.zero()

#### Int64.prototype.constructor(value)

#### Int64.prototype.add(b)

#### Int64.prototype.and(b)

#### Int64.prototype.dec()

#### Int64.prototype.inc()

#### Int64.prototype.not()

#### Int64.prototype.or(b)

#### Int64.prototype.shiftLeft(b)

#### Int64.prototype.shiftRight(b)

#### Int64.prototype.shiftRightArithmetic(b)

#### Int64.prototype.shiftRightLogical(b)

#### Int64.prototype.sub(b)

#### Int64.prototype.toInt32()

#### Int64.prototype.toJSON()

#### Int64.prototype.toPostgres()

#### Int64.prototype.toString(radix = 10)

#### Int64.prototype.toUint32()

#### Int64.prototype.xor(b)

### class Iterator

#### Iterator.indices(arr)

- `arr`: [``][array] array-like object to create indices from

_Returns:_ ``

Create iterator over indices of an array

#### Iterator.range(start, stop\[, step\])

- `start`: [``][number]

- `stop`: [``][number]

- `step`: [``][number] (optional), default: `1`

_Returns:_ ``

Create iterator iterating over the range

#### Iterator.zip(...iterators)

- `iterators`: [``][array]

_Returns:_ ``

Create iterator by zipping multiple provided iterators into one

#### Iterator.prototype.constructor(base)

#### Iterator.prototype.apply(fn)

- `fn`: [``][function]

  - `this`: ``

_Returns:_ the result of `fn(this)` call.

Call a function with `this`. Will be equivalent to calling `fn(it)`.

#### Iterator.prototype.chain(...iterators)

#### Iterator.prototype.chainApply(fn)

- `fn`: [``][function]

  - `this`: ``

_Returns:_ `` result of `fn(this)` wrapped in an Iterator.

Call a function with `this` and wrap the result in an Iterator.

_Example:_

```js

iter([1, 2])

  .chainApply(([a, b]) => [a + b, a - b])

  .join(', ');

```

_Result:_

```js

'3, -1';

```

#### Iterator.prototype.collectTo(CollectionClass)

#### Iterator.prototype.collectWith(obj, collector)

#### Iterator.prototype.count()

#### Iterator.prototype.each(fn, thisArg)

#### Iterator.prototype.enumerate()

#### Iterator.prototype.every(predicate, thisArg)

#### Iterator.prototype.filter(predicate, thisArg)

#### Iterator.prototype.filterMap(mapper\[, thisArg\[, filterValue\]\])

- `mapper`: [``][function] function that maps values and returns

  either new value that will be the next value of the new iterator or

  `filterValue` that will be ignored.

  - `value`: `` iterator element

- `thisArg`: `` value to be used as `this` when calling `mapper`

- `filterValue`: `` value to filter out `mapper` results.

Creates an iterator that both filters and maps with the passed `mapper`.

This iterator will call `mapper` on each element and if mapper returns NOT

`filterValue` it will be returned, otherwise it is ignored.

#### Iterator.prototype.find(predicate, thisArg)

#### Iterator.prototype.findCompare(comparator\[, accessor\[, thisArg\]\])

- `comparator`: [``][function] returns `true` if new value should be

  accepted

  - `currValue`: `` current value, starts with undefined

  - `nextValue`: `` next value

  - _Returns:_ [``][boolean] `true` if next value should be accepted

- `accessor`: [``][function] gets value to compare by, current

  iterator value is used by default

  - `value`: `` current iterator value

  - _Returns:_ `` value to compare by

- `thisArg`: `` value to be used as `this` when calling `accessor` and

  `comparator`

_Returns:_ last iterator value where `comparator` returned `true`,

[``][undefined] by default

Find value in this iterator by comparing every value with

the found one using `comparator`

#### Iterator.prototype.firstNonNullable(\[defaultValue\])

- `defaultValue`: `` value to return if this iterator doesn't have

  non-nullable values

- _Returns:_ first non-nullable value or ``

Finds first non-nullable value in this iterator

#### Iterator.prototype.flat(depth = 1)

#### Iterator.prototype.flatMap(mapper, thisArg)

#### Iterator.prototype.forEach(fn, thisArg)

#### Iterator.prototype.groupBy(classifier\[, thisArg\])

- `classifier`: [``][function] gets value to group by

  - `value`: `` current iterator value

  - _Returns:_ `` value to group by

- `thisArg`: `` value to be used as `this` when calling `classifier`

- _Returns:_ [``][map] map with arrays of iterator values grouped by keys

  returned by `classifier`

Consumes an iterator grouping values by keys

#### Iterator.prototype.includes(element)

#### Iterator.prototype.join(sep = ', ', prefix = '', suffix = '')

#### Iterator.prototype.last(\[defaultValue\])

- `defaultValue`: `` value to be used if iterator is empty

_Returns:_ ``|[``][undefined] last value of this iterator or

[``][undefined]

Consumes an iterator returning last iterator value

#### Iterator.prototype.map(mapper, thisArg)

#### Iterator.prototype.max(\[accessor\[, thisArg\]\])

- `accessor`: [``][function] gets value to compare by, current

  iterator value is used by default

  - `value`: `` current iterator value

  - _Returns:_ `` value to compare by

- `thisArg`: `` value to be used as `this` when calling `accessor`

_Returns:_ element with maximum value or [``][undefined] if iterator

is empty

Find the maximum value in this iterator

#### Iterator.prototype.min(\[accessor\[, thisArg\]\])

- `accessor`: [``][function] gets value to compare by, current

  iterator value is used by default

  - `value`: `` current iterator value

  - _Returns:_ `` value to compare by

- `thisArg`: `` value to be used as `this` when calling `accessor`

_Returns:_ element with minimum value or [``][undefined] if iterator

is empty

Find the minimum value in this iterator

#### Iterator.prototype.next()

#### Iterator.prototype.partition(predicate\[, thisArg\])

- `predicate`: [``][function] function returns a value to partition

  this iterator

  - `value`: `` current iterator element

  - _Returns:_ [``][boolean]|[``][number] key denoting

    resulting partition this value will be assigned to. Number denotes index in

    the resulting array. Boolean will be cast to number

- `thisArg`: `` value to be used as `this` when calling `predicate`

- _Returns:_ [``][array] array of partitions (arrays), will always have

  at least 2 arrays in it

Consumes an iterator, partitioning it into Arrays

#### Iterator.prototype.reduce(reducer, initialValue)

#### Iterator.prototype.skip(amount)

#### Iterator.prototype.skipWhile(predicate, thisArg)

#### Iterator.prototype.some(predicate, thisArg)

#### Iterator.prototype.someCount(predicate, count, thisArg)

#### Iterator.prototype.take(amount)

#### Iterator.prototype.takeWhile(predicate, thisArg)

#### Iterator.prototype.toArray()

#### Iterator.prototype.toObject()

Transforms an iterator of key-value pairs into an object.

This is similar to what [`Object.fromEntries()`][object.fromentries()] would

offer.

#### Iterator.prototype.zip(...iterators)

### iter(base)

### iterEntries(obj)

### iterKeys(obj)

### iterValues(obj)

### cryptoPrefetcher(bufSize, valueSize)

- `bufSize`: [``][number] size in bytes of the buffer to preallocate

- `valueSize`: [``][number] size in bytes of the produced chunks

Create prefetcher to use when crypto.randomBytes is required to generate

multiple same-size values. `bufSize` must be a multiple of `valueSize` for this

to work.

### random(min, max)

- `min`: [``][number] range start

- `max`: [``][number] range end

_Returns:_ [``][number]

Generate random integer value in given range

### cryptoRandom()

_Returns:_ [``][number]

Generate random number in the range from 0 inclusive up to

but not including 1 (same as Math.random), using crypto-secure number generator.

### methods(iface)

- `iface`: [``][object] to be introspected

_Returns:_ [`