open-index/open-npm huggingface dataset:
npm package: @softlightweb/softlightweb-components
Description: >
Latest version: 1.29.0

# @softlightweb/softlightweb-components

> 

[![NPM](https://img.shields.io/npm/v/@softlightweb/softlightweb-components.svg)](https://www.npmjs.com/package/@softlightweb/softlightweb-components) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save @softlightweb/softlightweb-components
```

## Usage

```tsx
import * as React from 'react'

import MyComponent from '@softlightweb/softlightweb-components'

class Example extends React.Component {
  render () {
    return (
      <MyComponent />
    )
  }
}
```

## License

MIT © [](https://github.com/)
npm package: @softlightweb/svelte
Description: Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/master/packages/create-svelte).
Latest version: 1.0.8

# create-svelte

Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/master/packages/create-svelte).

Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).

## Creating a project

If you're seeing this, you've probably already done this step. Congrats!

```bash
# create a new project in the current directory
npm create svelte@latest

# create a new project in my-app
npm create svelte@latest my-app
```

## Developing

Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:

```bash
npm run dev

# or start the server and open the app in a new browser tab
npm run dev -- --open
```

Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.

## Building

To build your library:

```bash
npm run package
```

To create a production version of your showcase app:

```bash
npm run build
```

You can preview the production build with `npm run preview`.

> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.

## Publishing

Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).

To publish your library to [npm](https://www.npmjs.com):

```bash
npm publish
```
npm package: @softman/react-editable-label
Description: A simple React component for switching between a text label and a text input
Author: Nikhil CM
Latest version: 1.2.0

# EditableLabel
This is just an extension of [react-editable-label](https://www.npmjs.com/package/react-editable-label) 

A simple React component for switching between a text label and a text input.

Clicking on the text label switches the label to a text input. A loss of focus on the text input will switch back to the text label and save the text changes.

An `ESC` key press will switch from text input back to label and discard any changes made to the text in the input.

An `ENTER` key press will switch from text input back to label and save any changes made.

When a save is triggered, the `save` function passed in as a prop is called with the current value of the input.

![Label view](https://i.imgur.com/zZokjZO.png)

![Input view](https://i.imgur.com/vLPgHOg.png)

## Table of Contents

* [Installation](#installation)
* [Usage](#usage)

## Installation

`$ npm install react-editable-label`
`$ yarn add react-editable-label`

## Usage
The `EditableLabel` object requires two props:

- `initialValue` which is the initial text to display
- `save` which is the function called when the text is updated.

Optional props:

- `labelClass` which is added to the `className` of the label `<span>` tag.
- `inputClass` which is added to the `className` of the text `<input>` tag.
- `disableKeys` which disables the keyPress handler.
- `type` input type.

Example:

```
import React from 'react';
import {render} from 'react-dom';

import EditableLabel from 'react-editable-label';

class App extends React.Component {
    render () {
        return (
            <div className="container">
                <div className="row">
                    <div className="col-md-4 col-md-offset-2">
                        <p>Hello!</p>
                        <EditableLabel
                            initialValue={'World'}
                            type={"text"}
                            save={value => {
                                console.log(`Saving '${value}'`);
                            }}
                        />
                    </div>
                </div>
            </div>
        );
    }
}

let app = document.getElementById('app');

if (app) {
    render(<App/>, app);
}
```
npm package: @softmedialab/24feb
Description: > Поиск токсичных пакетов 'https://raw.githubusercontent.com/stravnik/toxic-repos/main/data/json/toxic-repos.json' и указанных символов
Author: SML
Latest version: 1.0.1

# @softmedialab/24feb

> Поиск токсичных пакетов 'https://raw.githubusercontent.com/stravnik/toxic-repos/main/data/json/toxic-repos.json' и указанных символов

## 1) Установите

```
$ npm install @softmedialab/24feb
```

```
$ yarn add @softmedialab/24feb
```

При необходимости пакет можно установить глобально (добавим соответствующие флаги)

```
$ npm install -g @softmedialab/24feb
```

```
$ yarn global add @softmedialab/24feb
```

## 2) Настройте конфигурацию (опционально)

Для настройки необходимо в папке проекта (там где package.json) разместить файл **config24feb.json**

Если файла нет, то будут использованы базовые настройки:

```json
{
  "rootDir": "node_modules/**",
  "charsForCheck": [
    {
      "char": "🇷🇺",
      "desc": "flag_RU"
    },
    {
      "char": "🇺🇦",
      "desc": "flag_UKR"
    }
  ],
  "ignorePatterns": [],
  "extraPaths": [],
  "throwIfFound": true
}
```

По настройке символов ("charsForCheck"):

Символы, такие как emoji, могут не отображаться в консоли должным образом. Некоторые операционные системы не поддерживают вывод символов из Unicode, а некоторые требуют установки дополнительных пакетов. Если вы уверены, что ваша ОС поддерживает специальные символы, такие как "🇷🇺", тогда в "desc" также можно указать "🇷🇺"

### Пример дополнительных полей и настроек при создании config24feb.json

```json
{
  "rootDir": "node_modules/**",
  "charsForCheck": [
    {
      "char": "🇷🇺",
      "desc": "🇷🇺"
    },
    {
      "char": "🇺🇦",
      "desc": "flag_UKR"
    }
  ],
  "ignorePatterns": ["node_modules/es5-ext/_postinstall.js"],
  "extraPaths": ["src/**"],
  "throwIfFound": true
}
```

## 3) Запустите сканирование

Если пакет был установлен **не глобально** тогда необходимо, в package.json проекта добавить

```json
  "scripts": {
    "24feb": "24feb run",
  },
```

После этого в терминале выполнить команды

```
$ npm run 24feb
```

или (в зависимости от используемого установщика пакетов)

```
$ yarn 24feb
```

Если пакет был установлен **глобально** тогда достаточно выполнить команду

```
24feb run
```
npm package: @softmedialab/dagre-d3
Description: A D3-based renderer for Dagre
Author: Nikolay Khudkov
Latest version: 0.0.4

# dagre-d3 - A D3-based renderer for dagre

[Dagre](https://github.com/dagrejs/dagre) is a JavaScript library that makes it easy to lay out directed graphs on
the client-side. The dagre-d3 library acts as a front-end to dagre, providing
actual rendering using [D3](http://d3js.org).

For more details, including examples and configuration options, please see our
[wiki](https://github.com/dagrejs/dagre-d3/wiki).

## License

dagre-d3 is licensed under the terms of the MIT License. See the LICENSE file
for details.
npm package: @softmg/vite-plugin-react-lazy-component
Description: lazy import for react
Author: Aleksandr Saburov
Latest version: 1.0.0

# @softmg/vite-plugin-react-lazy-component

This plugin allows you to use renderToString with Suspense.

On client using react lazy. On ssr using root level await.

## Getting Started

Install the package as a dev dependency.

```bash
# npm
npm install --save-dev @softmg/vite-plugin-react-lazy-component

# pnpm
pnpm install --save-dev @softmg/vite-plugin-react-lazy-component

# yarn
yarn add --dev @softmg/vite-plugin-react-lazy-component

# bun
add add --D @softmg/vite-plugin-react-lazy-component
```

Add the plugin to your vite.config.ts file.

```ts
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import lazyComponentPlugin from "@softmg/vite-plugin-react-lazy-component";

// https://vitejs.dev/config/
export default defineConfig((config) => {
  return {
    build: {
      target: config.isSsrBuild ? "node20" : false, // target node required for root level await
    },
    plugins: [
      lazyComponentPlugin(),
      react(),
    ],
  };
});
```

Add the reference to your vite-env.d.ts file.
```dts
/// <reference types="@softmg/vite-plugin-react-lazy-component/client" />
```

## Using

```ts
import { Suspense } from "react";
import { lazy } from "virtual:lazy-component";

const Example = lazy(() => import("./Example"));

function App() {
  return (
    <>
      <Suspense>
        <Example data="data" />
      </Suspense>
    </>
  );
}

export default App;
```
npm package: @softmila/adonisjs-socketio
Description: Socket.io package for AdonisJS
Author: Tsiresy Milà
Latest version: 1.7.1

# @softmila/adonisjs-socketio

<br />

[![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url]

## Introduction

**AdonisJS-SocketIO** provides JavaScript API to implementation **socketio** in **AdonisJS** applications.

## Installation

```bash
node ace add @softmila/adonisjs-socketio
```

## Usage

Create a service to handle event from socketio

```typescript
// SocketIoServiceHandler.ts
import { OnMessage, OnceMessage, OnAnyMessage} from '@softmila/adonisjs-socketio'

export default class SocketIoServiceHandler {

  @OnMessage('on_message')
  async onMessageHandler(socket: Socket, data: any){
    console.log('Data:::', data)
    const io = await app.container.make('io')
    socket.emit('on_response', {data "ok"})
  }

  @OnceMessage('once_message')
  async onceMessageHandler(socket: Socket, data: any){
    console.log('Data:', data)
  }

  @OnAnyMessage()
  async onAnyMessageHandler(socket: Socket, data: any){
    console.log('Data:', data)
  }
}
```

**io** is avalaible in **HttpContext** and **ContainerBindings** .

Note: Services that handle socketio event can't inject dependency that depends **HttpContext**.

## License

**Adonisjs-SocketIO** is open-sourced software licensed under the [MIT license](LICENSE.md).

[npm-image]: https://img.shields.io/npm/v/@softmila/adonisjs-socketio/latest.svg?style=for-the-badge&logo=npm
[npm-url]: https://www.npmjs.com/package/@softmila/adonisjs-socketio/v/latest "npm"

[typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript

[license-url]: LICENSE.md
[license-image]: https://img.shields.io/github/license/tsiresymila1/adonisjs-socketio?style=for-the-badge
npm package: @softmilkui/core
Description: <a alt="Nx logo" href="https://nx.dev" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-logo.png" width="45"></a>
Latest version: 0.1.4
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# SoftmilkUi

<a alt="Nx logo" href="https://nx.dev" target="_blank" rel="noreferrer"><img src="https://raw.githubusercontent.com/nrwl/nx/master/images/nx-logo.png" width="45"></a>

✨ **This workspace has been generated by [Nx, Smart Monorepos · Fast CI.](https://nx.dev)** ✨

## Integrate with editors

Enhance your Nx experience by installing [Nx Console](https://nx.dev/nx-console) for your favorite editor. Nx Console
provides an interactive UI to view your projects, run tasks, generate code, and more! Available for VSCode, IntelliJ and
comes with a LSP for Vim users.

## Build the library

Run `npx nx build` to build the library. The build artifacts are stored in the output directory (i.e. `dist/`), ready to be published.

## Running tasks

To execute tasks with Nx use the following syntax:

```
npx nx <target> <project> <...options>
```

You can also run multiple targets:

```
npx nx run-many -t <target1> <target2>
```

..or add `-p` to filter specific projects

```
npx nx run-many -t <target1> <target2> -p <proj1> <proj2>
```

Targets can be defined in the `package.json` or `projects.json`. Learn more [in the docs](https://nx.dev/features/run-tasks).

## Set up CI!

Nx comes with local caching already built-in (check your `nx.json`). On CI you might want to go a step further.

- [Set up remote caching](https://nx.dev/features/share-your-cache)
- [Set up task distribution across multiple machines](https://nx.dev/nx-cloud/features/distribute-task-execution)
- [Learn more how to setup CI](https://nx.dev/recipes/ci)

## Explore the project graph

Run `npx nx graph` to show the graph of the workspace.
It will show tasks that you can run with Nx.

- [Learn more about Exploring the Project Graph](https://nx.dev/core-features/explore-graph)

## Connect with us!

- [Join the community](https://nx.dev/community)
- [Subscribe to the Nx Youtube Channel](https://www.youtube.com/@nxdevtools)
- [Follow us on Twitter](https://twitter.com/nxdevtools)
npm package: @softmotions/coc-svelte
Description: Svelte language support for coc.nim
Author: iamcco
Latest version: 0.4.2

# Svelte for (Neo)Vim

> fork from [svelte-vscode](https://github.com/sveltejs/language-tools/tree/master/packages/svelte-vscode).

Provides rich intellisense for Svelte components in (neo)vim, utilising the [svelte language server](https://github.com/sveltejs/language-tools/tree/master/packages/language-server).

## Install

``` vim
:CocInstall coc-svelte
```

> You have to install syntax plugin to get syntax highlight and get right filetype, for example `leafOfTree/vim-svelte-plugin`

## Setup

If you added `"files.associations": {"*.svelte": "html" }` to your CoC settings, remove it.

Do you want to use TypeScript/SCSS/Less/..? [See the docs](/docs/README.md#language-specific-setup).

## Features

-   Svelte
    -   Diagnostic messages for warnings and errors
    -   Support for svelte preprocessors that provide source maps
    -   Svelte specific formatting (via [prettier-plugin-svelte](https://github.com/sveltejs/prettier-plugin-svelte))
-   HTML
    -   Hover info
    -   Autocompletions
    -   [Emmet](https://emmet.io/)
    -   Symbols in Outline panel
-   CSS / SCSS / LESS
    -   Diagnostic messages for syntax and lint errors
    -   Hover info
    -   Autocompletions
    -   Formatting (via [prettier](https://github.com/prettier/prettier))
    -   [Emmet](https://emmet.io/)
    -   Color highlighting and color picker
    -   Symbols in Outline panel
-   TypeScript / JavaScript
    -   Diagnostics messages for syntax errors, semantic errors, and suggestions
    -   Hover info
    -   Formatting (via [prettier](https://github.com/prettier/prettier))
    -   Symbols in Outline panel
    -   Autocompletions
    -   Go to definition
    -   Code Actions

##### `svelte.plugin.XXX`

Settings to toggle specific features of the extension. The full list of all settings [is here](https://github.com/sveltejs/language-tools/blob/master/packages/language-server/README.md#List-of-settings).

### Usage with Yarn 2 PnP

1. Run `yarn add -D svelte-language-server` to install svelte-language-server as a dev dependency
2. Run `yarn dlx @yarnpkg/pnpify --sdk vim` to generate or update the Vim/Yarn integration SDKs.
3. Set the `svelte.language-server.ls-path` setting in your user configuration, pointing it to the workspace-installed language server.
4. Restart vim.
5. Commit the changes to `.yarn/sdks`
npm package: @softmotions/react-native-fetch-mock
Description: fetch mock for react-native
Author: Itgro forked from WhatAKitty
Latest version: 0.7.2

# react-native-fetch-mock
[![Build Status](https://travis-ci.org/WhatAKitty/react-native-fetch-mock.svg?branch=master)](https://travis-ci.org/WhatAKitty/react-native-fetch-mock)
[![Known Vulnerabilities](https://snyk.io/test/npm/react-native-fetch-mock/badge.svg)](https://snyk.io/test/npm/react-native-fetch-mock)

fetch mock for react-native

[React Version](https://github.com/WhatAKitty/react-fetch-mock)

## Why FetchMock ?
No fetch mock could be used easily for react-native.  
So, I create one by myself.

## Roadmap
- [x] Combined with Mock.js
- [x] Support exclude for some other path
- [x] Proxy for other api server
- [x] Delay for global and specific path
- [ ] Support RAP system

## Usage

__ mocks__/index.js
```
export default {
  '/api/path': ({ method, url, params, urlparams, headers }) => {
    const all = Mock.mock({
      'list|2': [{
        'id|+1': 1,
        'name': '@first @last',
        'age|18-54': 1,
      }]
    }).list;
    return all;   // default status is 200
  },
  '/api/path/{id}': ({ method, url, params, urlparams, headers }) => {
    const all = Mock.mock({
      'list|2': [{
        'id|+1': 1,
        'name': '@first @last',
        'age|18-54': 1,
        'urlid': urlparams.id,
      }]
    }).list;
    return all;
  },
  'POST /api/path': ({ method, url, params, urlparams, headers }) => {
    return {
      status: 201,
    };
  },
  'PUT /api/path/${id}': ({ method, url, params, urlparams, headers }) => {
    return {
      status: 204,
      id: urlparams.id,
    };
  },
}
```
index.js
```
import FetchMock from 'react-native-fetch-mock';

if (__dev__) {
  global.fetch = new FetchMock(require('path/to/mocks/directory'), {
    delay: 200, // 200ms
    fetch: global.fetch,
    exclude: [
      'http://www.google.com',
      '/foo(.*)',
    ],
    proxy: [{
      path: '/path/for/proxy(.*)',
      target: 'http://other.proxy.server',
      process: (proxied, matches) => {
        return `${proxied.target}${matches[1]}`,
      },
    }],
  }).fetch;
}

// if __dev__ is true, it will back the data you defined in mock directory
fetch('/api/path', options);
fetch('/api/path', {
  delay: 2000,      // /api/path will delayed after 2000ms. Most of suitation, this won't be used usually.
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'John',
  }),
});
fetch('/api/path/123', {
  method: 'PUT',
  headers: {
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    name: 'John2',
  }),
});
```

## Example Runing

```
git clone git@github.com:WhatAKitty/react-native-fetch-mock.git
cd react-native-fetch-mock/example/Basic
npm install (attention: don't use yarn while install example dep)
react-native run-ios
```

## LICENSE

MIT
npm package: @softmotions/riot-typed
Description: a tiny wrapper layer for riotjs to write riot tags with benefits of typescipt
Author: Adamansky Anton
Latest version: 1.1.2

# Why riot-typed

Write [riotjs](http://riotjs.com)  tags in a more oo-way with benefits of typescript

[![NPM version][npm-version-image]][npm-url]
[![NPM downloads][npm-downloads-image]][npm-url]
[![MIT License][license-image]][license-url]

## How to use

### install

support typescript@2.4.2.

```sh
npm install -g typescript
npm install -g typings
```

```sh
npm install --save-dev riot-typed
```

install riot typed definitions

```sh
typings install -DG github:Joylei/riot-typed/src/riot.d.ts#2ca54b484694b133cbe6f58347242f6a1e273e17
```

install riot-typed typed definitions

```sh
typings install -DG github:Joylei/riot-typed/src/riot-typed.d.ts#2ca54b484694b133cbe6f58347242f6a1e273e17
```

### usage

let's define a tag

```ts
//file: tags/app.ts
import {tag, Tag} from 'riot-typed';
@tag('app', '<h1>{title}</h1>')
class App extends Tag<any>{
  title:string;
  constructor(){
    this.title = 'Hello riot-typed!'
  }
}
```

let's mount the tag

```ts
//file: main.ts
import 'tags/app';
riot.mount('app');
```

### override

It's possible to override definition properties: tmpl|attrs|css.

```ts
//file: logger.ts
import {tag, Tag} from 'riot-typed';

@tag('logger',{ tmpl: '<p class="color" each="{ item in logs }">{ item }</p>', css: '.color{color:gray;}' })
export default class Logger extends Tag<any>{
    logs: string[];

    constructor(){
        super();

        this.logs = ['line 1', 'line 2'];
    }
}
```

override css definition only:

```ts
//file: error-logger.ts
@tag('error-logger',{ css: 'error-logger .color{color:red;}' })
export default class ErrorLogger extends Logger{
    constructor(){
        super();

        this.logs.push('!!!Error!!!');
    }
}
```

### examples

please see [examples](https://github.com/Joylei/riot-typed-example) for more information.

## tag() decorator

tag(tagName: string, tmpl?: string | { tmpl?: string, css?: string, attrs?: string })

## restrictions

please see [riot.tag()](http://riotjs.com/api/#manual-construction) for restrictions.

## License

MIT

[license-image]:http://img.shields.io/badge/license-MIT-000000.svg?style=flat-square
[license-url]:LICENSE

[npm-version-image]:http://img.shields.io/npm/v/riot-typed.svg?style=flat-square
[npm-downloads-image]:http://img.shields.io/npm/dm/riot-typed.svg?style=flat-square
[npm-url]:https://npmjs.org/package/riot-typed
npm package: @softmotions/wscat
Description: WebSocket cat
Author: Arnout Kazemier, Einar Otto Stangvik
Latest version: 4.0.1

# wscat

WebSocket cat.

## Installation

This module needs to be installed globally so use the `-g` flag when installing:

```
npm install -g wscat
```

## Usage

```
Usage: wscat [options] (--listen <port> | --connect <url>)

Options:
  -V, --version                       output the version number
  -l, --listen <port>                 listen on port
  -c, --connect <url>                 connect to a WebSocket server
  -p, --protocol <version>            optional protocol version
  -o, --origin <origin>               optional origin
  -x, --execute <command>             execute command after connecting
  -w, --wait <seconds>                wait given seconds after executing command
  -P, --show-ping-pong                print a notification when a ping or pong is received
  --host <host>                       optional host
  -s, --subprotocol <protocol>        optional subprotocol (default: [])
  -n, --no-check                      do not check for unauthorized certificates
  -H, --header <header:value>         set an HTTP header. Repeat to set multiple (--connect only) (default: [])
  --auth <username:password>          add basic HTTP authentication header (--connect only)
  --ca <ca>                           specify a Certificate Authority (--connect only)
  --cert <cert>                       specify a Client SSL Certificate (--connect only)
  --key <key>                         specify a Client SSL Certificate's key (--connect only)
  --passphrase [passphrase]           specify a Client SSL Certificate Key's passphrase (--connect only). If you don't provide a value, it will be prompted for
  --no-color                          run without color
  --slash                             enable slash commands for control frames (/ping, /pong, /close [code [, reason]])
  --proxy <[protocol://]host[:port]>  connect via a proxy. Proxy must support CONNECT method
  -h, --help                          output usage information
```

## Example

```
$ wscat -c ws://echo.websocket.org
Connected (press CTRL+C to quit)
> hi there
< hi there
> are you a happy parrot?
< are you a happy parrot?
```

## License

MIT
npm package: @softnami/neuralnetwork
Description: Artificial neural network for data prediction.
Author: Hussain Mir Ali
Latest version: 1.0.14

# Shallow Neural Network 
### [Author: Hussain Mir Ali]
#### [Hire me,](mailto:hkmirali+npm@gmail.com) I can build your next project. 

<img src="https://upload.wikimedia.org/wikipedia/commons/1/1e/Artificial_Neural_Network.jpg"  width="500px" alt="shallownetwork"></img>

An artificial neural network with single hidden layer and multiclass classification. The applications include modelling non-linear data.

## Note: 
* Please perform Feature Scaling and/or Mean Normalization along with random shuffling of data for using this program.

## Installation:
*  Run 'npm install @softnami/neuralnetwork'.

### Sample usage:

```javascript
//main.js file

import NeuralNetwork from '@softnami/neuralnetwork';

let callback_data;

//callback for diagnostics
let callback = function (data) {
    console.log(data);
    callback_data = data;
};

let nn =  new NeuralNetwork({
        'hiddenLayerSize': 12,
        'learningRate': 0.1,
        'threshold': undefined /*optional threshold value for cost. Defaults to 1/(e^3).*/ ,
        'regularization_parameter': 0.001 /*optional regularization parameter to prevent overfitting. Defaults to 0.01.*/ ,
        'optimization_mode': {
          'mode': 1,
          'batch_size': 2
        } /*optional optimization mode for type of gradient descent. {mode:1, 'batch_size': <your size>} for mini-batch and {mode: 0} for batch. Defaults to batch gradient descent.*/ ,
        'notify_count': 10 /*optional value to execute the callback after every x number of iterations. Defaults to 100. */ ,
        'iteration_callback': callback /*optional callback that can be used for getting cost and iteration value on every notify count. Defaults to empty function.*/ ,
        'maximum_iterations': 100 /*optional maximum iterations to be allowed. Defaults to 1000.*/
      });

nn.train_network([
    [1, 0, 1, 1, 1, 1],
    [0, 1, 1, 0, 0, 0],
    [1, 0, 0, 1, 0, 1],
    [0, 0, 1, 0, 0, 0],
    [1, 1, 0, 1, 1, 1],
    [1, 0, 0, 1, 0, 1]
], [
    [1,1,1],
    [1,0,1],
    [0,1,0],
    [1,0,0],
    [1,1,0],
    [0,1,0]
]).then(console.log(nn.predict_result([[1,0,0,1,0,1]])));  

*/
```

## Testing:
* For unit testing Mocha and Sinon have been used. 
* Run 'npm test', if timeout occurs then increase timeout in test script.

## Documentation
*  The documentation is available in the 'out' folder of this project. Open the 'index.html' file under the 'out' folder with Crhome or Firefox.
*  To generate the  documentation run 'yuidoc .' command in the main directory of this project.
npm package: @softnami/quicksort
Description: Quicksort algorithm in typescript.
Author: Hussain Mir Ali
Latest version: 1.0.16

# Quicksort:

### [Author: Hussain Mir Ali] 
#### [Hire me,](mailto:hkmirali+npm@gmail.com) I can build your next project. 

This is a module for the Quicksort algorithm and helps you sort arrays. It is built with TypeScript, is light weight and has no dependencies.

```javascript
import Quicksort from '@softnami/quicksort';

let arry: number[] = [];

//generating ramdom data for demo
for (let i = 0; i < 10; i++) {
  arry[i] = Math.floor(Math.random() * 5 + 0);
}


//shuffling the array of numbers
for (let i = 0; i < 10; i++) {
  let randomindex = Math.floor(Math.random() * 9 + 0);
  let temp = arry[i];
  arry[i] = arry[randomindex];
  arry[randomindex] = temp;
}

console.log('UnsortedArray', arry);

/*UnsortedArray [
  4, 4, 1, 2, 1,
  4, 3, 2, 2, 4
]*/

let sorter: Quicksort = new Quicksort();
            sorter.sort(arry);

console.log('Sorted Array', arry);

/*Sorted Array [
  1, 1, 2, 2, 2,
  3, 4, 4, 4, 4
]*/
```