open-index/open-npm huggingface dataset:
npm package: @ngaox/devkit
Description: Schematics, Builders and other dev utilities for developing Angular apps with Ngaox.
Author: Rabyâ Raghib
Latest version: 5.0.0

# Ngaox Devkit

[![Ngaox for Angular](https://img.shields.io/badge/Angular-Ngaox-red.svg)](https://ngaox-lab.web.app)
[![npm Version](https://img.shields.io/npm/v/@ngaox/devkit)](https://ngaox-lab.web.app/docs/devkit)
[![Monthly Downloads](https://img.shields.io/npm/dm/@ngaox/devkit)](https://www.npmjs.com/package/@ngaox/devkit)

**Schematics, Builders and other dev utilities for developing Angular apps with Ngaox.**

## [Getting Started with Ngaox Devkit](https://ngaox-lab.web.app/)
npm package: @ngaox/icons
Description: Inline SVG icons from (src | files | your favorite icons library | ...)!
Author: Rabyâ Raghib
Latest version: 6.0.0

# Ngaox Icons

[![Ngaox for Angular](https://img.shields.io/badge/Angular-Ngaox-red.svg)](https://ngaox-lab.web.app)
[![npm Version](https://img.shields.io/npm/v/@ngaox/icons)](https://ngaox-lab.web.app/docs/icons)
[![Monthly Downloads](https://img.shields.io/npm/dm/@ngaox/icons)](https://www.npmjs.com/package/@ngaox/icons)

**Inline SVG icons from (src | files | your favorite icons library | ...)!**

## [Getting Started with Ngaox Icons](https://ngaox-lab.web.app/docs/icons)

## Samples

```html
<ngaox-icon name="my-icon" width="100px"></ngaox-icon>
```
npm package: @ngaox/press
Description: Write your content how you wish!
Author: Rabyâ Raghib
Latest version: 5.0.0

# Ngaox Press

[![Ngaox for Angular](https://img.shields.io/badge/Angular-Ngaox-red.svg)](https://ngaox-lab.web.app)
[![npm Version](https://img.shields.io/npm/v/@ngaox/press)](https://ngaox-lab.web.app/docs/press)
[![Monthly Downloads](https://img.shields.io/npm/dm/@ngaox/press)](https://www.npmjs.com/package/@ngaox/press)

**Write your content how you wish!**

## [Getting Started with Ngaox Press](https://ngaox-lab.web.app/docs/press)
npm package: @ngaox/seo
Description: Easily generate and manage SEO-friendly meta tags, page title,...
Author: Rabyâ Raghib
Latest version: 6.0.0

# Ngaox Seo

[![Ngaox for Angular](https://img.shields.io/badge/Angular-Ngaox-red.svg)](https://ngaox-lab.web.app)
[![npm Version](https://img.shields.io/npm/v/@ngaox/seo)](https://ngaox-lab.web.app/docs/seo)
[![Monthly Downloads](https://img.shields.io/npm/dm/@ngaox/seo)](https://www.npmjs.com/package/@ngaox/seo)

**Easily generate and manage SEO-friendly meta tags, page title,...**

## [Getting Started with Ngaox Seo](https://ngaox-lab.web.app/docs/seo)

## Samples

```ts
// Angular router routes
const routes: Routes = [
  {
    path: 'users',
    data: {
      // This 👇 will be used as the page seo data
      NgaoxSeo: {
        title: 'Users List Page',
        description: 'A short description goes here.',
        siteName: 'Ngaox'
      }
    }
  }
];
```

---

```html
<!-- Also available as an angular component -->
<ngaox-seo
  title="Hello World"
  description="This is a description"
  keywords="keyword1, keyword2, keyword3"
  [twitter]="{
    site: '@NgaoxLab',
    creator: '@rabraghib'
  }"
></ngaox-seo>
```
npm package: @ngard/promise-some
Description: The complementary function to Promise.all()
Author: Nick Gard
Latest version: 1.1.1

# promise-some

[![source](https://badgen.net/npm/v/@ngard/promise-some)](https://www.npmjs.com/package/@ngard/promise-some)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/promise-some)](https://bundlephobia.com/result?p=@ngard/promise-some)
[![build status](https://badgen.net/travis/NickGard/promise-some)](https://travis-ci.org/NickGard/promise-some)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A complementary function to `Promise.all()` that will resolve if any passed `Promise` resolves and rejects only if all of the passed `Promise`s reject. The rejection handler is passed an array containing the individual `Promise`'s rejection reasons in the order the `Promise`s were passed in to `some` (not in the order in which they rejected).

<hr/>

## Syntax

```javascript
import { some } from '@ngard/promise-some';

some(/* iterable */)
```

## Parameter

`iterable` — An iterable object containing `Promise`s or other values

## Return

* An already rejected `Promise` if the iterable passed is empty.
* An asynchronously resolved `Promise` if the iterable passed contains a non-`Promise` value.
* A pending `Promise` in all other cases. This returned promise is then resolved/rejected asynchronously (as soon as the stack is empty) when any of the promises in the given iterable have resolved, or if any of the promises resolves. Returned values will be in order of the `Promise`s passed, regardless of completion order.

<hr/>

## Examples

```javascript
const p1 = Promise.resolve('p1 resolved');
const p2 = new Promise(() => {});

some([ p1, p2 ]).then((val) => console.log(val));
// logs "p1 resolved"
```

```javascript
const p1 = Promise.resolve('p1 resolved');

some([ p1, 'not a promise' ]).then((val) => console.log(val));
// logs "not a promise"
```

```javascript
const p1 = new Promise((resolve, reject) => {
  setTimeout(reject, 300, 'p1 rejected');
});
const p2 = new Promise((resolve, reject) => {
  setTimeout(reject, 100, 'p2 rejected');
});
const p3 = new Promise((resolve, reject) => {
  setTimeout(reject, 200, 'p3 rejected');
});

some([ p1, p2, p3 ]).catch((val) => console.log(val));
// logs ["p1 rejected", "p2 rejected", "p3 rejected"]
```

<hr/>

<div class="alert alert-info">

**Note:** This utility relies on `Array.from` which is not supported in Internet Explorer. However, `Promise` is also not supported in IE. If you are polyfilling `Promise` for older browsers, you will also need to polyfill `Array.from`.

</div>
npm package: @ngard/tiny-chunk
Description: A minimal-weight lodash.chunk similar utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-chunk

[![source](https://badgen.net/npm/v/@ngard/tiny-chunk)](https://www.npmjs.com/package/@ngard/tiny-chunk)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-chunk)](https://bundlephobia.com/result?p=@ngard/tiny-chunk)
[![build status](https://badgen.net/travis/NickGard/tiny-chunk)](https://travis-ci.org/NickGard/tiny-chunk)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility similar to `lodash.chunk`. For when every byte counts!
The only difference is that `tiny-chunk` has a minimum chunk size of `1` instead of `0`.

<hr/>

lodash.chunk [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.chunk)](https://bundlephobia.com/result?p=lodash.chunk)
<br/>
tiny-chunk [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-chunk)](https://bundlephobia.com/result?p=@ngard/tiny-chunk)

<hr/>

## Syntax

```js
chunk(/* array [, chunkSize] */)
```

## Parameters

`array` - An array to chunk
<br/>
`chunkSize` - [optional] A positive numerical value that designates the size of the chunks to be created. Non-numeric values will default to `1`. Non-integer values will round down to the nearest integer.

## Return

An array of elements split into groups the length of `chunkSize`. If the array can't be split evenly, the final chunk will be the remaining elements.

## Example

```javascript
import { chunk } from '@ngard/tiny-chunk';

const value = chunk([1, 2, 3, 4, 5], 2);
// value is [[1, 2], [3, 4], [5]]
```
npm package: @ngard/tiny-compose
Description: A minimal-weight composition utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-compose

[![source](https://badgen.net/npm/v/@ngard/tiny-compose)](https://www.npmjs.com/package/@ngard/tiny-compose)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-compose)](https://bundlephobia.com/result?p=@ngard/tiny-compose)
[![build status](https://badgen.net/travis/NickGard/tiny-compose)](https://travis-ci.org/NickGard/tiny-compose)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal composition utility. For when every byte counts!
Creates a new function that applies the arguments to the right-most function and applies the result of that call to the function to its left and so on for all functions passed. That function returns the result of these nested calls.

```js
compose(fn1, fn2, fn3)('yeah!')

// is equivalent to
fn1(fn2(fn3('yeah!')))
```

<hr/>

## Install

```bash
npm install @ngard/tiny-compose
```

## Syntax

```javascript
compose(/* function1 [, function2 [, ...] ] */);
```

## Parameters
`function1` - Any function

## Return
A new function that applies the arguments to the right-most function and applies the result of that call to the function to its left and so on for all functions passed. That function returns the result of these nested calls.

<hr/>

## Examples

```javascript
import { compose } from '@ngard/tiny-compose';

function biggerThanZero(n) {
  return Math.max(0, n);
}
function lessThanTen(n) {
  return Math.min(10, n);
}
const betweenZeroAndTen = compose(biggerThanZero, lessThanTen);

betweenZeroAndTen(4); // returns 4
betweenZeroAndTen(14); // returns 10
betweenZeroAndTen(-8); // returns 0
```

```javascript
import { compose } from '@ngard/tiny-compose';

function double(n) {
  return 2 * n;
}
function addFive(n) {
  return 5 + n;
}
const addFiveAndDouble = compose(double, addFive);
addFiveAndDouble(4); // 18

const doubleAndAddFive = compose(addFive, double);
doubleAndAddFive(4); // 13
```
npm package: @ngard/tiny-curry
Description: A minimal-weight currying utility similar to lodash.curry
Author: Nick Gard
Latest version: 1.0.1

# tiny-curry

[![source](https://badgen.net/npm/v/@ngard/tiny-curry)](https://www.npmjs.com/package/@ngard/tiny-curry)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-curry)](https://bundlephobia.com/result?p=@ngard/tiny-curry)
[![build status](https://badgen.net/travis/NickGard/tiny-curry)](https://travis-ci.org/NickGard/tiny-curry)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal utility similar to `lodash.curry`. For when every byte counts!
Returns a series of functions that consume the original function's arguments one at a time until the original function's arity (or the passed arity) is met.

<hr/>

lodash.curry: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.curry)](https://bundlephobia.com/result?p=lodash.curry)
<br/>
tiny-curry: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-curry)](https://bundlephobia.com/result?p=@ngard/tiny-curry)

<hr/>

## Install

```bash
npm install @ngard/tiny-curry
```

## Syntax

```javascript
curry(/* function [, arity] */);
```

## Parameters

`function` - A function that will be called once the parameters are gathered through currying.
`arity` - The number of curry functions to create before returning the result of the passed function called with the arguments. Defaults to `function.length`.

## Returns
A series of functions that each take a single argument and apply those arguments to the supplied function once they have all been gathered. Each intermediate function also has a `value` method that may be invoked to apply the currently gathered arguments to the function.

## Examples

```javascript
import { curry } from '@ngard/tiny-curry';

function add(a, b) { return a + b; }
// add.length = 2, the number of arguments it expects

const curriedAdd = curry(add);
const addTwo = curriedAdd(2);

console.log(addTwo(5)); // logs '7'
```

```javascript
import { curry } from '@ngard/tiny-curry';

function greet(name, title = 'Your Lordship') {
  return `Good day,  ${name}, ${title}`;
}
// greet.length = 1, because defaulted arguments are not 'expected'

const curriedGreet = curry(greet, 2);
const greetBob = curriedGreet('Bob');

console.log(greetBob('my friend')); // logs 'Good day, Bob, my friend'
console.log(greetBob()); // logs 'Good day, Bob, Your Lordship'
```

```javascript
import { curry } from '@ngard/tiny-curry';

function sum(...numbers) {
  return numbers.reduce((total, number) => total + number);
}
// sum.length = 0, because rest arguments are not 'expected'

const curriedSum = curry(sum, Infinity);

// call `.value()` on an infinitely curried function to call the
// original function with the gathered arguments
const total = curriedSum(1)(2)(3)(4).value();

console.log(total); // logs '10'
```
npm package: @ngard/tiny-debounce
Description: A minimal-weight utility equivalent to lodash.debounce
Author: Nick Gard
Latest version: 1.0.0

# tiny-debounce

[![source](https://badgen.net/npm/v/@ngard/tiny-debounce)](https://www.npmjs.com/package/@ngard/tiny-debounce)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-debounce)](https://bundlephobia.com/result?p=@ngard/tiny-debounce)
[![build status](https://badgen.net/travis/NickGard/tiny-debounce)](https://travis-ci.org/NickGard/tiny-debounce)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal utility similar to `lodash.debounce`. For when every byte counts!

<hr/>

lodash.debounce: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.debounce)](https://bundlephobia.com/result?p=lodash.debounce)
<br/>
tiny-debounce: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-debounce)](https://bundlephobia.com/result?p=@ngard/tiny-debounce)

<hr/>

## Install

```sh
npm install @ngard/tiny-debounce
```

## Syntax

```javascript
debounce(/* function, waitTime [, { leading, trailing, maxWait} ] */);
```

## Parameters

`function` - `[Function]` The function to be throttled.
`waitTime` - `[Number=0]` The amount of time, in milliseconds, to wait between the last invocation of the function and firing the passed function. The passed function will be invoked with the arguments from the most recent invocation of the debounced function.
`options.leading` - `[Boolean=false]` If true, the passed function will be fired on the leading edge of the debounce time period.
`options.trailing` - `[Boolean=true]` If true, the passed function will be fired on the trailing edge of the debounce time period.
`options.maxWait` - `[Number]` The maximum amount of time, in milliseconds, to allow the passed function to be debounced before invoking.

## Returns
A debounced function with the methods `flush` and `cancel`.
`debouncedFn.flush()` will immediately fire any debounced invocation and stop the debouncing timer.
`debouncedFn.cancel()` will cancel any debounced invocation and stop the debouncing timer.

## Note
If `leading` and `trailing` options are `true`, func is invoked on the trailing edge of the timeout only if the debounced function is invoked more than once during the wait timeout.

If wait is `0` and `leading` is `false`, func invocation is deferred until to the next tick, similar to `setTimeout` with a timeout of `0`.

## Example

```javascript
import { debounce } from '@ngard/tiny-debounce';

const debouncedAnimation = debounce(animateSomething, 16)
window.addListener('scroll', debouncedAnimation);
window.addListener('resize', debouncedAnimation.cancel);
```
npm package: @ngard/tiny-difference
Description: A minimal-weight lodash.difference equivalent utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-difference

[![source](https://badgen.net/npm/v/@ngard/tiny-difference)](https://www.npmjs.com/package/@ngard/tiny-difference)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-difference)](https://bundlephobia.com/result?p=@ngard/tiny-difference)
[![build status](https://badgen.net/travis/NickGard/tiny-difference)](https://travis-ci.org/NickGard/tiny-difference)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility identical to `lodash.difference`. For when every byte counts!

<hr/>

lodash.difference [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.difference)](https://bundlephobia.com/result?p=lodash.difference)
<br/>
tiny-difference [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-difference)](https://bundlephobia.com/result?p=@ngard/tiny-difference)

<hr/>

## Syntax

```js
difference(/* array, [...arrays] */)
```

## Parameters

`array` - The array to calculate the difference to. Resulting array elements are in the same order as appear in this array
<br/>
`arrays` - Any number of other arrays, whose elements will not appear in the returned array

## Return

A new array containing only the elements found in the first array and **not** in the other arrays, in the order as they appear in the first array.

## Example

```javascript
import { difference } from '@ngard/tiny-difference';

const diff = difference([1,2,3,4], [1,2]); // returns [3,4]
const diff = difference([1,2,3,4], [1,2], [2,3,5]); // returns [4]
```
npm package: @ngard/tiny-flatten
Description: A minimal-weight lodash.flatten equivalent utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-flatten

[![source](https://badgen.net/npm/v/@ngard/tiny-flatten)](https://www.npmjs.com/package/@ngard/tiny-flatten)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-flatten)](https://bundlephobia.com/result?p=@ngard/tiny-flatten)
[![build status](https://badgen.net/travis/NickGard/tiny-flatten)](https://travis-ci.org/NickGard/tiny-flatten)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility equivalent to `lodash.flatten`. For when every byte counts!

<hr/>

lodash.flatten [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.flatten)](https://bundlephobia.com/result?p=lodash.flatten)
<br/>
tiny-flatten [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-flatten)](https://bundlephobia.com/result?p=@ngard/tiny-flatten)

<hr/>

## Syntax

```js
flatten(/* array */)
```

## Parameters

`array` - An array to flatten

## Return

Flattens an array a single level deep.

## Example

```javascript
import { flatten } from '@ngard/tiny-flatten';

const value = flatten([1, [2, 3], [4, [5]]]);
// returns [1, 2, 3, 4, [5]]
```
npm package: @ngard/tiny-get
Description: A minimal-weight lodash.get equivalent utility
Author: Nick Gard
Latest version: 1.2.2

# tiny-get

[![source](https://badgen.net/npm/v/@ngard/tiny-get)](https://www.npmjs.com/package/@ngard/tiny-get)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-get)](https://bundlephobia.com/result?p=@ngard/tiny-get)
[![build status](https://badgen.net/travis/NickGard/tiny-get)](https://travis-ci.org/NickGard/tiny-get)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility similar to `lodash.get`. For when every byte counts!

<hr/>

lodash.get [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.get)](https://bundlephobia.com/result?p=lodash.get)
<br/>
tiny-get [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-get)](https://bundlephobia.com/result?p=@ngard/tiny-get)

<hr/>

## Syntax

```js
get(/* root, path [, default] */)
```

## Parameters

`root` - An object or array to traverse
<br/>
`path` - A string of the path, or an array of property names to be traversed
<br/>
`default` - [optional] A value to be returned if the path does not exist or results in an undefined value

## Return

The value found at the path on the root object or array, if it exists. If the path is invalid or results in
an undefined value, then `tiny-get` will return `undefined` or the default value if passed.

## Example

```javascript
import { get } from '@ngard/tiny-get';

const value = get(baseObj, 'really.deep.value', 'defaultValue');
const value = get(baseObj, 'really["deep"].value', 'defaultValue');
const value = get(baseObj, ['really', 'deep', 'value'], 'defaultValue');
```
npm package: @ngard/tiny-isempty
Description: A minimal-weight lodash.isEmpty equivalent utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-isempty

[![source](https://badgen.net/npm/v/@ngard/tiny-isempty)](https://www.npmjs.com/package/@ngard/tiny-isempty)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-isempty)](https://bundlephobia.com/result?p=@ngard/tiny-isempty)
[![build status](https://badgen.net/travis/NickGard/tiny-isempty)](https://travis-ci.org/NickGard/tiny-isempty)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility equivalent to `lodash.isempty`. For when every byte counts!

<hr/>

lodash.isempty [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.isempty)](https://bundlephobia.com/result?p=lodash.isempty)
<br/>
tiny-isempty [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-isempty)](https://bundlephobia.com/result?p=@ngard/tiny-isempty)

<hr/>

## Syntax

```js
isEmpty(/* object */)
```

## Parameters

`object` - The object to check for emptiness

## Return

`true` if value is an empty object, collection, map, or set. `false` otherwise.

Objects are considered empty if they have no own enumerable string keyed properties.

Array-like values such as `arguments` objects, `arrays`, `strings`, or jQuery-like collections are considered empty if they have a length of `0`. Similarly, `maps` and `sets` are considered empty if they have a size of `0`.

## Example

```javascript
import { isEmpty } from '@ngard/tiny-isempty';

isEmpty({}); // true
isEmpty([]); // true
isEmpty(''); // true
isEmpty(new Map()); // true
isEmpty(Object.create(null)); // true
```
npm package: @ngard/tiny-isequal
Description: A minimal-weight utility similar to lodash.isequal
Author: Nick Gard
Latest version: 1.1.0

# tiny-isequal

[![source](https://badgen.net/npm/v/@ngard/tiny-isequal)](https://www.npmjs.com/package/@ngard/tiny-isequal)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-isequal)](https://bundlephobia.com/result?p=@ngard/tiny-isequal)
[![build status](https://badgen.net/travis/NickGard/tiny-isequal)](https://travis-ci.org/NickGard/tiny-isequal)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility similar to `lodash.isequal`. For when every byte counts!
Performs a deep (recursive) comparison between the two arguments. It differs from
`lodash.isequal` in one significant way: it requires that the two values have the
same prototype and properies, including unenumerable ones.

<hr/>

lodash.isequal: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.isequal)](https://bundlephobia.com/result?p=lodash.isequal)
<br/>
tiny-isequal: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-isequal)](https://bundlephobia.com/result?p=@ngard/tiny-isequal)

<hr/>

## Install

```bash
npm install @ngard/tiny-isequal
```

## Syntax

```javascript
isEqual(/* value1, value2 */);
```

## Parameters

`value1` - Any Javascript value
`value2` - Any Javascript value

## Return

`true` if the two values are deeply equal, `false` otherwise.

<hr/>

## Examples

```javascript
import { isEqual } from "@ngard/tiny-isequal";

const samesies = isEqual({ a: 1 }, { a: 1 });
// samesies is true
```

```javascript
import { isEqual } from "@ngard/tiny-isequal";

const samesies = isEqual({ a: { b: "c" } }, { a: { b: "c" } });
// samesies is true
```

```javascript
import { isEqual } from "@ngard/tiny-isequal";

const obj = [1, 2, 3];
const samesies = isEqual(obj, obj);
// samesies is true
```

```javascript
import { isEqual } from "@ngard/tiny-isequal";

const samesies = isEqual(NaN, NaN);
// samesies is true
```
npm package: @ngard/tiny-isplainobject
Description: A minimal-weight lodash.isPlainObject equivalent utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-isplainobject

[![source](https://badgen.net/npm/v/@ngard/tiny-isplainobject)](https://www.npmjs.com/package/@ngard/tiny-isplainobject)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-isplainobject)](https://bundlephobia.com/result?p=@ngard/tiny-isplainobject)
[![build status](https://badgen.net/travis/NickGard/tiny-isplainobject)](https://travis-ci.org/NickGard/tiny-isplainobject)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility equivalent to `lodash.isPlainObject`. For when every byte counts!

<hr/>

lodash.isplainobject [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.isplainobject)](https://bundlephobia.com/result?p=lodash.isplainobject)
<br/>
tiny-isplainobject [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-isplainobject)](https://bundlephobia.com/result?p=@ngard/tiny-isplainobject)

<hr/>

## Syntax

```js
isPlainObject(/* object */)
```

## Parameters

`object` - An object (or any value) to check

## Return

`true` if value is a plain object, that is, an object created by the `Object` constructor or one with a `[[Prototype]]` of `null`. `false` otherwise.

## Example

```javascript
import { isPlainObject } from '@ngard/tiny-isplainobject';

isPlainObject({ a: 1 }); // true
isPlainObject(Object.create(null)); // true

isPlainObject(null); // false
isPlainObject([1,2,3]); // false
isPlainObject(new Set()); // false
```
npm package: @ngard/tiny-memoize
Description: A minimal-weight lodash.memoize similar utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-memoize

[![source](https://badgen.net/npm/v/@ngard/tiny-memoize)](https://www.npmjs.com/package/@ngard/tiny-memoize)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-memoize)](https://bundlephobia.com/result?p=@ngard/tiny-memoize)
[![build status](https://badgen.net/travis/NickGard/tiny-memoize)](https://travis-ci.org/NickGard/tiny-memoize)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility similar to `lodash.memoize`. For when every byte counts!

<hr/>

lodash.memoize [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.memoize)](https://bundlephobia.com/result?p=lodash.memoize)
<br/>
tiny-memoize [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-memoize)](https://bundlephobia.com/result?p=@ngard/tiny-memoize)

<hr/>

## Syntax

```js
memoize(/* function [, maxMemoizations, reconciler] */)
```

## Parameters

`function` - The function to memoize
<br/>
`maxMemoizations` - [optional = `1`] A positive numerical value that designates the number of unique function calls to memoize. Non-numeric and non-positive values will default to `1`. Positive non-integer values will round down to the nearest integer, or up to `1` for values between `0` and `1`.
<br/>
`reconciler` - [optional] A function that compares two cache keys for equality. Cache keys are `arguments` objects. The default reconciler checks each argument for equality using `===`.

## Return

A function that will return the value of the arguments applied to the passed function, either by invoking the function or by performing a lookup (by arguments) of previously generated values.

## Example

```javascript
import { memoize } from '@ngard/tiny-memoize';

const efficientPrimeCalculator = memoize(isPrime, Infinity);
efficientPrimeCalculator(1000000000000066600000000000001); // isPrime is called, returns true
efficientPrimeCalculator(1000000000000066600000000000001); // isPrime is NOT called, returns true
```

```javascript
import { memoize } from '@ngard/tiny-memoize';

const isSamePerson = (args1, args2) => {
  const person1 = args1[0];
  const person2 = args2[0];
  return person1.id === person2.id;
};
const greet = memoize(person => `Hi, ${person.givenName}!`, 1, isSamePerson);
greet({
  id: 845739,
  givenName: 'Janine',
  surname: 'Bloomfield',
  occupation: 'senior accountant',
  birthdate: new Date('Jan 02 1991')
}); // calculates 'Hi, Janine!'
greet({
  id: 845739,
  givenName: 'Janine',
  surname: 'Bloomfield',
  occupation: 'CTO',
  birthdate: new Date('Jan 02 1991')
}); // returns memoized result 'Hi, Janine!'
```
npm package: @ngard/tiny-omit
Description: A minimal-weight utility equivalent to lodash.omit
Author: Nick Gard
Latest version: 1.0.0

# tiny-omit

[![source](https://badgen.net/npm/v/@ngard/tiny-omit)](https://www.npmjs.com/package/@ngard/tiny-omit)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-omit)](https://bundlephobia.com/result?p=@ngard/tiny-omit)
[![build status](https://badgen.net/travis/NickGard/tiny-omit)](https://travis-ci.org/NickGard/tiny-omit)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal utility equivalent to `lodash.omit`. For when every byte counts!

<hr/>

lodash.omit: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.omit)](https://bundlephobia.com/result?p=lodash.omit)
<br/>
tiny-omit: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-omit)](https://bundlephobia.com/result?p=@ngard/tiny-omit)

<hr/>

## Install

```sh
npm install @ngard/tiny-omit
```

## Syntax

```javascript
omit(/* source, key [, key2, ...] */);
```

## Parameters

`source` - `[Object|Array]` The object whose key/value pairs will be omitted.
`key [, key2, ...]` - `[String|Array<String>]` An array or list of key names.

## Returns
An object comprised of the un-omitted key/value pairs.

## Example

```javascript
import { omit } from '@ngard/tiny-omit';

const person = {
  name: 'Luke Skywalker',
  description: 'whiny Jedi',
  address: '312 Sand St, Tatooine',
  SSN: '123456789'
}

const safe = omit(person, 'address', 'SSN');
// { name: 'Luke Skywalker', description: 'whiny Jedi' }

const safe = omit(person, ['address', 'SSN']);
// { name: 'Luke Skywalker', description: 'whiny Jedi' }

/* Omitting Array indexes */
omit(['a', 'b', 'c'], 0, 2); // { 1: 'b' }
```
npm package: @ngard/tiny-pick
Description: A minimal-weight utility equivalent to lodash.pick
Author: Nick Gard
Latest version: 1.0.0

# tiny-pick

[![source](https://badgen.net/npm/v/@ngard/tiny-pick)](https://www.npmjs.com/package/@ngard/tiny-pick)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-pick)](https://bundlephobia.com/result?p=@ngard/tiny-pick)
[![build status](https://badgen.net/travis/NickGard/tiny-pick)](https://travis-ci.org/NickGard/tiny-pick)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal utility equivalent to `lodash.pick`. For when every byte counts!

<hr/>

lodash.pick: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.pick)](https://bundlephobia.com/result?p=lodash.pick)
<br/>
tiny-pick: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-pick)](https://bundlephobia.com/result?p=@ngard/tiny-pick)

<hr/>

## Install

```sh
npm install @ngard/tiny-pick
```

## Syntax

```javascript
pick(/* source, key [, key2, ...] */);
```

## Parameters

`source` - `[Object|Array]` The object whose key/value pairs will be picked.
`key [, key2, ...]` - `[String|Array<String>]` An array or list of key names.

## Returns
An object comprised of the picked key/value pairs.

## Example

```javascript
import { pick } from '@ngard/tiny-pick';

const character = {
  name: 'Luke Skywalker',
  description: 'whiny Jedi',
  planet: 'Tatooine',
  system: 'Jabak',
}

const bio = pick(character, 'name', 'description');
// { name: 'Luke Skywalker', description: 'whiny Jedi' }

const address = pick(character, ['planet', 'system']);
// { planet: 'Tatooine', system: 'Jabak' }

/* Picking Arrays */
pick(['a', 'b', 'c'], 0, 2); // { 0: 'a', 2: 'c' }
```
npm package: @ngard/tiny-pipe
Description: A minimal-weight pipe utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-pipe

[![source](https://badgen.net/npm/v/@ngard/tiny-pipe)](https://www.npmjs.com/package/@ngard/tiny-pipe)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-pipe)](https://bundlephobia.com/result?p=@ngard/tiny-pipe)
[![build status](https://badgen.net/travis/NickGard/tiny-pipe)](https://travis-ci.org/NickGard/tiny-pipe)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal composition utility. For when every byte counts!
Creates a new function that applies the arguments to the left-most function and applies the result of that call to the function to its right and so on for all functions passed. That function returns the result of these nested calls.

```js
pipe(fn1, fn2, fn3)('yeah!')

// is equivalent to
fn3(fn2(fn1('yeah!')))
```

<hr/>

## Install

```bash
npm install @ngard/tiny-pipe
```

## Syntax

```javascript
pipe(/* function1 [, function2 [, ...] ] */);
```

## Parameters
`function1` - Any function

## Return
A new function that applies the arguments to the left-most function and applies the result of that call to the function to its right and so on for all functions passed. That function returns the result of these nested calls.

<hr/>

## Examples

```javascript
import { pipe } from '@ngard/tiny-pipe';

function biggerThanZero(n) {
  return Math.max(0, n);
}
function lessThanTen(n) {
  return Math.min(10, n);
}
const betweenZeroAndTen = pipe(biggerThanZero, lessThanTen);

betweenZeroAndTen(4); // returns 4
betweenZeroAndTen(14); // returns 10
betweenZeroAndTen(-8); // returns 0
```

```javascript
import { pipe } from '@ngard/tiny-pipe';

function double(n) {
  return 2 * n;
}
function addFive(n) {
  return 5 + n;
}
const doubleAndAddFive = pipe(double, addFive);
doubleAndAddFive(4); // 13

const addFiveAndDouble = pipe(addFive, double);
addFiveAndDouble(4); // 18
```
npm package: @ngard/tiny-throttle
Description: A minimal-weight utility similar to lodash.throttle
Author: Nick Gard
Latest version: 1.1.0

# tiny-throttle

[![source](https://badgen.net/npm/v/@ngard/tiny-throttle)](https://www.npmjs.com/package/@ngard/tiny-throttle)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-throttle)](https://bundlephobia.com/result?p=@ngard/tiny-throttle)
[![build status](https://badgen.net/travis/NickGard/tiny-throttle)](https://travis-ci.org/NickGard/tiny-throttle)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal utility similar to `lodash.throttle`. For when every byte counts!

<hr/>

lodash.throttle: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.throttle)](https://bundlephobia.com/result?p=lodash.throttle)
<br/>
tiny-throttle: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-throttle)](https://bundlephobia.com/result?p=@ngard/tiny-throttle)

<hr/>

## Install

```sh
npm install @ngard/tiny-throttle
```

## Syntax

```javascript
throttle(/* function, interval */);
```

## Parameters

`function` - The function to be throttled.
`interval` - The amount of time, in milliseconds, to wait between invocations of the function. All function calls made during this interval are ignored.

## Returns
A throttled function.

## Example

```javascript
import { throttle } from '@ngard/tiny-throttle';

window.addListener('scroll', throttle(animateSomething, 16));
```
npm package: @ngard/tiny-unescape
Description: A minimal-weight lodash.unescape equivalent utility
Author: Nick Gard
Latest version: 1.0.0

# tiny-unescape

[![source](https://badgen.net/npm/v/@ngard/tiny-unescape)](https://www.npmjs.com/package/@ngard/tiny-unescape)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-unescape)](https://bundlephobia.com/result?p=@ngard/tiny-unescape)
[![build status](https://badgen.net/travis/NickGard/tiny-unescape)](https://travis-ci.org/NickGard/tiny-unescape)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal-weight utility equivalent to `lodash.unescape`. For when every byte counts!

<hr/>

lodash.unescape [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.unescape)](https://bundlephobia.com/result?p=lodash.unescape)
<br/>
tiny-unescape [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-unescape)](https://bundlephobia.com/result?p=@ngard/tiny-unescape)

<hr/>

## Syntax

```js
unescape(/* string */)
```

## Parameters

`string` - An string to unescape

## Return

Replaces escaped HTML characters (`&amp;`, `&lt;`, `&gt;`, `&quot;`, `&#39;`) with their unescaped forms (`&`, `<`, `>`, `"`, `'` respectively).

## Example

```javascript
import { unescape } from '@ngard/tiny-unescape';

const value = unescape('&amp;&lt;&gt;&quot;&#39;');
// returns &<>"'
```
npm package: @ngard/tiny-unique
Description: A minimal-weight deduplicating utility similar to lodash.uniq
Author: Nick Gard
Latest version: 1.0.0

# tiny-unique

[![source](https://badgen.net/npm/v/@ngard/tiny-unique)](https://www.npmjs.com/package/@ngard/tiny-unique)
[![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-unique)](https://bundlephobia.com/result?p=@ngard/tiny-unique)
[![build status](https://badgen.net/travis/NickGard/tiny-unique)](https://travis-ci.org/NickGard/tiny-unique)
[![license](https://badgen.net/badge/license/MIT/blue)](https://badgen.net/badge/license/MIT/blue)

A minimal utility similar to `lodash.uniq`. For when every byte counts!
Returns a copy of the passed array with only the first of any duplicate values included.

<hr/>

lodash.uniq: [![bundle size](https://badgen.net/bundlephobia/minzip/lodash.uniq)](https://bundlephobia.com/result?p=lodash.uniq)
<br/>
tiny-unique: [![bundle size](https://badgen.net/bundlephobia/minzip/@ngard/tiny-unique)](https://bundlephobia.com/result?p=@ngard/tiny-unique)

<hr/>

## Syntax

```javascript
unique(/* array [, comparator] */);
```

## Parameters

`array` - An array of possibly duplicated values
`comparator` - An optional function that compares two values for equality. Defaults to `===`.

## Returns
An array containing only the first occurrence of each value in the passed array, in the order that they occur.

## Use

```javascript
import { unique } from '@ngard/tiny-unique';

const set = unique([1, true, 'foo', 3, 1, true]);
// set is [1, true, 'foo', 3]
```
npm package: @ngartifex/card
Description: Material card library for angular
Author: turbongdev
Latest version: 1.0.6

# ADDAPPTABLES card

ngartifex card is a library for angular

[See demo](http://addapptables.com/admin/components/cards)

[Example code](https://stackblitz.com/edit/angular-card-addapptables)

## Getting Started
To get started, let's install the package through npm:

Choose the version corresponding to your Angular version:

 Angular     | @ngartifex/card
 ----------- | -------------------
 13          | 4.x
 12          | 3.x
 11          | 2.x
 10          | 1.x

```
npm i @ngartifex/card --S
```

Install peer dependencies

```
npm i
@ngartifex/core
@angular/material
@angular/animations
@angular/cdk --S
```

## How to use

- Import the module CardModule

```typescript
import { CardModule } from '@ngartifex/card';
@NgModule({
  imports: [CardModule]
})
export class YourModule { }
```

simple card
```html
<ngartifex-card>
  <card-header>
    <card-header-linear>
      <card-title>
        <mat-icon matSuffix>horizontal_split</mat-icon>
        <span>Simple card</span>
      </card-title>
    </card-header-linear>
  </card-header>
  <mat-divider></mat-divider>
  <card-body>
    // custom component
  </card-body>
</ngartifex-card>
```

Oval card
```html
<ngartifex-card>
  <card-header>
    <card-header-oval>
      <card-title>
        <mat-icon matSuffix>horizontal_split</mat-icon>
        <span>Oval card</span>
      </card-title>
    </card-header-oval>
  </card-header>
  <card-body>
    // custom component
  </card-body>
</ngartifex-card>
```

- Finally, it is important to import the styles to the application

```scss
@import '~@ngartifex/core/_ngartifex-grid.theme';
@import '~@angular/material/theming';
@import '~@ngartifex/card/_ngartifex-card.theme';

$ngartifex-app-primary: mat-palette($mat-teal, 800);
$ngartifex-app-accent:  mat-palette($mat-pink, 800, A100, 100);
$ngartifex-app-warn: mat-palette($mat-red);
$ngartifex-app-theme: mat-light-theme($ngartifex-app-primary, $ngartifex-app-accent, $ngartifex-app-warn);
$ngartifex-theme-variables: (
    text: white,
    border-radius: 5px,
    color-blue: #20a9d2,
    color-success: #5cb85c,
    color-info: #5bc0de,
    color-warning: #e09d3d,
    color-danger: #d43934,
    gray-color: #696868
);
@include mat-core();
body.theme-default {
    @include angular-material-theme($ngartifex-app-theme);
    @include card($ngartifex-app-theme, $ngartifex-theme-variables);
}
```

- Do not forget to put the theme-default class in the html body

```html
<body class="theme-default"></body>
```
npm package: @ngartifex/core
Description: ngartifex core library for angular
Author: turbongdev
Latest version: 1.0.6

# ADDAPPTABLES core

[See demo](http://addapptables.com/admin/dashboard)

## Getting Started
To get started, lets install the package thru npm:

Choose the version corresponding to your Angular version:

 Angular     | @addapptables/core
 ----------- | -------------------
 13          | 4.x
 12          | 3.x
 11          | 2.x
 10          | 1.x

```
npm i @crafsjs/core --S
```

## How to use

```scss
@import '~@crafsjs/core/crafsjs-grid.theme';
```
npm package: @ngartifex/modal
Description: Material modal is a library for angular
Author: turbongdev
Latest version: 1.0.6

# ngartifex modal

ngartifex modal is a library for angular

[See demo](http://ngartifex.com/admin/ecommerce/products)

## Getting Started
To get started, let's install the package through npm:

Choose the version corresponding to your Angular version:

 Angular     | @ngartifex/modal
 ----------- | -------------------
 13          | 4.x
 12          | 3.x
 11          | 2.x
 10          | 1.x

```
npm i @ngartifex/modal --S
```

Install peer dependencies

```
npm i
@ngartifex/perfect-scrollbar
perfect-scrollbar
@angular/material
@angular/cdk
@angular/animations --S
```

## How to use

- Import the module AlertModule into the AppModule

```typescript
import { ModalModule } from '@ngartifex/modal';
@NgModule({
  imports: [ModalModule.forRoot({ width: '800px' })]
})
export class AppModule { }
```

- Create a component modal

```typescript
@Component({
...
})
export class FormModalComponent {

  constructor(
    private _dialogRef: MatDialogRef<FormModalComponent>,
    @Optional() @Inject(MAT_DIALOG_DATA) public data: any
  ) { }

  close() {
    this._dialogRef.close();
  }

}
```

```html
<ngartifex-modal>
  <modal-header>
    <h3 class="text-accent">Title</h3>
    <button mat-icon-button (click)="close()">
      <mat-icon suffix>close</mat-icon>
    </button>
  </modal-header>
  <modal-body>
    //modal body
  </modal-body>
  <modal-footer>
    <button type="submit" mat-raised-button color="accent">
      Save
    </button>
    <button type="button" mat-raised-button (click)="close()">Close</button>
  </modal-footer>
</ngartifex-modal>
```

```typescript
import { ModalModule } from '@ngartifex/modal';

@NgModule({
  imports: [ModalModule],
  entryComponents: [
    FormModalComponent // this line is important
  ]
})
export class OtherModule { }
```

```typescript
@Component({
...
})
export class ProductListComponent {

  constructor(
    private _modalService: ModalService
  ) { }

  showModal() {
    this._modalService.show(FormModalComponent);
  }
}
```
npm package: @ngartifex/perfect-scrollbar
Description: Perfect scrollbar library for angular
Author: Addapptables
Latest version: 1.0.6

# ADDAPPTABLES Perfect-scrollbar
Utility for scroll browser

## Getting Started
To get started, let's install the package through npm:

Choose the version corresponding to your Angular version:

 Angular     | @ngartifex/perfect-scrollbar
 ----------- | -------------------
 13          | 4.x
 12          | 3.x
 11          | 2.x
 10          | 1.x

```
npm i @ngartifex/perfect-scrollbar perfect-scrollbar --S
```

## How to use

Import PerfectScrollbarModule in your module

```javascript
   import { PerfectScrollbarModule } from '@ngartifex/perfect-scrollbar';
    @NgModule({
        imports: [PerfectScrollbarModule]
    })
    export class AddapptableModule { }
```

```css
    .menu-scroll-container{
        position: relative; //this property is important
    }
```
```html
<div perfectScrollbar class="menu-scroll-container">
    ...large content
</div>
```

Options
```javascript
export interface Options {
    handlers?: string[];
    maxScrollbarLength?: number;
    minScrollbarLength?: number;
    scrollingThreshold?: number;
    scrollXMarginOffset?: number;
    scrollYMarginOffset?: number;
    suppressScrollX?: boolean;
    suppressScrollY?: boolean;
    swipeEasing?: boolean;
    useBothWheelAxes?: boolean;
    wheelPropagation?: boolean;
    wheelSpeed?: number;
  }
```

```html
<div perfectScrollbar [perfectScrollOptions]="{ wheelPropagation: true }" class="menu-scroll-container">
    ...large content
</div>
```
npm package: @ngasemjs/server-core
Description: NodeJS Framework to Create RPC Server
Author: Hadi Hidayat Hammurabi
Latest version: 0.0.6

# ngasemjs-server-core
NodeJS Framework to Create RPC Server 

As you know about [RPC](https://en.wikipedia.org/wiki/Remote_procedure_call),
this is way to communicate between applications. Here, you got a very cool RPC
server framework for NodeJS.

## How cool is this?
1. Zero dependencies, only use NodeJS native module.
2. Simple procedure call API
3. (i will define it next day, maybe :v)

## How to use?
### Installation
First, create your NodeJs project using `npm init` command.
Then run command below inside that project.

```npm i @ngasemjs/rpc-server```

### Creating RPC Server
To starting your RPC server, you have to create a file that
calling the listen method from this RPC framework. You can
follow example below.

```js
// importing the framework
const rpc = require('@ngasemjs/rpc-server');

// run RPC server on port 8080
rpc.listen(8080, () => {
  console.log('RPC server is running...');
});
```

### Creating a Procedure
Before a procedure called, you have to define it.
To do this, see the example below.

```js
rpc.def('sum', (a, b) => {
  return a + b;
});
```

### Calling the Procedure
To call a procedure, you have to install client library for this framework.
You can see client provided list below.
1. [NodeJS](https://github.com/ngasemjs/client-nodejs)
2. [JavaScript](https://github.com/ngasemjs/client-javascript)

Or, you don't need to install any client, you can send HTTP request to the server
with rules below.
1. HTTP request to RPC server address (eg. http://localhost:8080)
2. Using **POST** request method
3. Put body like this:
```json
{
  "call": "procedureName",
  "parameters": [ 1, 2, 3, 4 ]
}
```

## Contributing
I hope everyone will contribute to this project, but i am not sure :v

If you want to contribute, fork and give me a pull request!
npm package: @ngasemjs/server-igniter
Description: NgasemJS igniter
Author: Hadi Hidayat Hammurabi
Latest version: 0.0.34

# server-igniter
NgasemJS igniter

## What is this?
This is part of NgasemJS framework that initialize all procedures
and setting up the project.

## How to use it?
### Installation
Run this command in your node project:
```bash
npm install --save @ngasemjs/server-igniter
```

### Register Project Directory
To register directory of the project, let's create file
called `server.js` and put this code.
```javascript
const { Igniter } = require('@ngasemjs/server-igniter');

Igniter
  .register(__dirname)
  .listen(() => console.log('RPC server has been started'))
  .catch(console.log);
```

Run this file using `node server.js` command.

It will be display an error until directory called `procedure` created.