open-index/open-npm huggingface dataset:
npm package: @runningcodertest/sprint-scripts
Description: Configuration and scripts for Create React App.
Latest version: 0.1.0

# react-scripts

This package includes scripts and configuration used by [Create React App](https://github.com/facebook/create-react-app).<br>
Please refer to its documentation:

* [Getting Started](https://github.com/facebook/create-react-app/blob/master/README.md#getting-started) – How to create a new app.
* [User Guide](https://github.com/facebook/create-react-app/blob/master/packages/react-scripts/template/README.md) – How to develop apps bootstrapped with Create React App.
npm package: @runninghill/ng-rsa-form-validators
Description: A set of South African specific validators for Angular forms.
Author: Runninghill Software Development
Latest version: 1.2.0

![Runninghill Logo](https://github.com/Runninghill/rh-angular-rsa-form-validators/blob/67badb0d7a78dca5c7ccacb729bbb3e5b0c5f8db/docs/runninghill.png?raw=true "Runninghill")

# Angular South African Form Validators

> Please note that this is the README for consumers, if you
> plan on contributing to this package, please take a
> look [here](https://github.com/Runninghill/rh-angular-rsa-form-validators/blob/main/projects/rh-rsa-form-validators/README.md).

A set of South African specific validators for Angular forms.

# Getting Started🏁

If you plan on contributing to the package please read the contributor readme.

1. Run `npm install rh-angular-rsa-form-validators` in your Angular project.

2. Import and use the exposed classes to validate your Angular form controls.

# Usage💡

To begin validating your South African specific form fields, start by importing
the _RsaFormValidators_ class.

```Javascript
import { RsaFormValidator } from 'rh-angular-rsa-form-validators'
```

Add the appropriate validator to your form control(s).

```Javascript
// When creating your form
this.form = this.formBuilder.group({
    name: ['', Validators.required],
    mobileNumber: ['', [Validators.required, RsaFormValidator.phoneNumber(false, true)]],
    workNumber: ['']
})

// After the form is already created
this.form.controls['workNumber'].setValidators([RsaFormValidators.phoneNumber(false, true)])
```

To determine if the form control passed the validation, check the errors object on the form control.

RsaFormValidator error objects on form controls will always be the name of the validator, 
prefixed with 'rsa' eg; for the rsa phone number validator, the error object is `rsaPhoneNumber`
(rsa + phoneNumber = rsaPhoneNumber) 

```Javascript
if (this.form.controls['mobileNumber'].errors.rsaPhoneNumber)
    errorMessage = 'Mobile number must be a valid South African phone number.'
```

# API Reference📖

### RsaFormValidator

Contains form control validators used to validate South African specific form fields.

[_source code_](https://github.com/Runninghill/rh-angular-rsa-form-validators/blob/main/projects/rh-rsa-form-validators/src/lib/validators/rsa-form-validator.ts)

#### Methods

##### phoneNumber(allowCountryCode, allowSpaces)

Returns a validator which determines if a form control is a valid South African phone number.

Parameters

|Name|Type|Description|Default|
|----|----|-----------|-------|
|allowCountryCode|boolean|determines if the phone number is allowed to contain the South African country code (+27)|true|
|allowSpaces|boolean|determines if a phone number is allowed to contain spaces|true|
npm package: @runningsnail/node-operate-file
Description: node 操作文件
Author: snail
Latest version: 1.0.3

# node 环境 文件操作

在写 node 脚本的时候，都不可避免的需要操作文件。因此将常用的遍历和操作文件及其文件的逻辑进行封装。

## API

- 获取指定文件夹下所有的文件路径


```typescript

getFilePaths(folder:string,options=ObtainFilesOptions):string[]

```

folder: 文件夹路径；

options: 相关配置。deep 为 true 时，表示进行深度遍历；



- 获取指定文件夹下所有的文件和文件夹 Stat 信息

```typescript

getFileAndFolder(folder:string,options=ObtainFilesOptions):Stats[]

```

folder: 文件夹路径；

options: 相关配置。deep 为 true 时，表示进行深度遍历；

- 获取指定文件夹下的所有文件和文件夹信息,并根据传入的函数过滤

```typescript

obtainFilesForFilter(folder: string, options: ObtainFilesOptions, fn: (stat: Stats) => void):Stats[]

```

folder: 文件夹路径；

options: 相关配置。deep 为 true 时，表示进行深度遍历；

fn: 回调函数

- 获取指定文件夹下的所有文件信息

```typescript

obtainFiles(folder: string, options?: ObtainFilesOptions):Stats[]

```

folder: 文件夹路径；

options: 相关配置。deep 为 true 时，表示进行深度遍历；
npm package: @runningwater/lorem
Description: returns a Lorem ipsum string
Latest version: 0.1.1

# @runningwater/lorem

![npm (scoped)](https://img.shields.io/npm/v/@runningwater/lorem)
![npm bundle size (scoped)](https://img.shields.io/bundlephobia/min/@runningwater/lorem)

@runningwater/lorem returns a Lorem ipsum string.

```js
const Lorem = require("@runningwater/lorem");

Lorem(4444);
// => lorem wants a number lower than 4444

Lorem(1234);
// => Running Water Lorem ipsum dolor sit amet, consectetur adipiscing elit....
```
npm package: @runno/host
Description: DEPRECATED iframe host for @runno
Author: Ben Taylor
Latest version: 0.5.2
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

👨‍💻 **Use Runno** 👉 [Runno.dev](https://runno.dev/)

📖 **Documentation** 👉 [Runno.dev](https://runno.dev/#host-api)

# Runno Host

This packages is meant to be used in concert with a `https://runno.run` client
iframe. The easiest way to create one is on the [Runno Website](https://runno.dev).

## Quickstart

Start by adding `@runno/host` to your package:

```
$ npm install @runno/host
```

Then you'll be able to import ConnectRunno.

```
import { ConnectRunno } from '@runno/host'
```

And use it with an existing Runno iframe.

```
const runno = await ConnectRunno(iframe);
```

To run a code sample interactively use interactiveRunCode.

```
const result = await runno.interactiveRunCode("python", codeSample);
```

The result has properties for stdin, stdout, stderr, tty, and fs (the file system). This represents the input that the user has typed, the output they received, any errors displayed and the full terminal text (input, output and errors).

If you want to run code without user input or output, you can use headlessRunCode.

```
const result = await runno.headlessRunCode("python", codeSample, stdin);
```

The stdin is optional, but necessary if the code expects input.

## Cross-Origin Headers

To get the best experience your page should provide a [Cross-Origin Isolated](https://web.dev/cross-origin-isolation-guide/) context so it can internally use SharedArrayBuffer. Without this Runno falls back to a lower performance hack that has the potential to break in the future.

To make your website Cross-Origin Isolated set the following headers in your HTTP response:

```
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp
```

You can test that your page is Cross-Origin Isolated by opening the browser console and checking `crossOriginIsolated` (see: [mdn docs](https://developer.mozilla.org/en-US/docs/Web/API/crossOriginIsolated)).
npm package: @runno/runtime
Description: Runtime for @runno
Author: Ben Taylor
Latest version: 0.10.0

👨‍💻 **Use Runno** 👉 [Runno.dev](https://runno.dev/)

📖 **Documentation** 👉 [Runno.dev](https://runno.dev/docs)

# Runno Runtime

The `@runno/runtime` implements all the core features to make code run. It also
exports Web Components that can be used to create runno instances in your code
without using iframes.

## Quickstart

Start by adding `@runno/runtime` to your package:

```sh
npm install @runno/runtime
```

Import `@runno/runtime` in whatever place you'll be using the runno elements.
The simplest is in your entrypoint file (e.g. `main.ts` or `index.ts`).

```js
import "@runno/runtime";
```

Once you've imported them you can use runno elements on the page.

```html
<runno-run runtime="python" editor controls> print('Hello, World!') </runno-run>
```

For the code to run though, you'll need to set some HTTP headers:

```
Cross-Origin-Opener-Policy: same-origin
Cross-Origin-Embedder-Policy: require-corp
```

These create a [cross-origin isolated context](https://web.dev/cross-origin-isolation-guide/) which allows the use of `SharedArrayBuffer` used to implement STDIN.

## Headless Usage

Runno supports a headless API.

```js
import { headlessRunCode, headlessRunFS } from "@runno/runtime";
```

You can use this headless API to run code in a particular language without
having to use the DOM. For example:

```js
const result = await headlessRunCode("python", "print('Hello World!')");
```

If you want to provide more than a single code snippet, you can use
`headlessRunFS` to provide each of the files, and the entrypoint file.

## Styling

The <code>runno-run</code> element can be styled with css
variables to change the height of the individual
<code>runno-editor</code> and <code>runno-terminal</code> elements
inside.

```css
runno-run {
  /* Sets a specific height for the editor */
  --runno-editor-height: auto;

  /* Sets a maximum height for the editor */
  --runno-editor-max-height: 60%;

  /* Sets a specific height for the terminal */
  --runno-terminal-height: auto;

  /* Sets a minimum height for the terminal */
  --runno-terminal-min-height: 4rem;
}
```

By default the editor will resize to fit the content you put
inside it, and the terminal will be its minimum height. If you set
the element to be a fixed height, they will share the space so
that the editor gets 60% and the controls and terminal get the
rest.
npm package: @runnpm/tokens
Description: An helper module that keeps track of all definnpay's supported tokens.
Author: runnpm
Latest version: 1.2.8

# @runnpm/tokens

An helper module that keeps track of all 8pay's supported tokens.

## Usage

```js
const Tokens = require('@runnpm/tokens');

const tokens = new Tokens(Tokens.Network.BSC);

// Get token by symbol
const token1 = tokens.get('DEFINN');
// Get token by address
const token2 = tokens.get('0x9876dkdu7d6d6f7f8g9g0h9h8C0caDBFa169042');
// List all tokens
const allTokens = tokens.all();

// Parse amount with decimals
tokens.parseAmount('1', 'DEFINN'); // 1000000000000000000
// Format amount with decimals
tokens.formatAmount('1000000000000000000', 'DEFINN'); // 1


console.log(token1);

/*
{
    name: 'DEFINN TOKEN',
    symbol: 'DEFINN',
    decimals: 18,
    address: '0x9876dkdu7d6d6f7f8g9g0h9h8C0caDBFa169042'
}
*/
```

## Supported networks

* BSC
npm package: @runonbitcoin/easy-b
Description: Simple library to manage B uploads
Author: runonbitcoin
Latest version: 0.2.2

# Easy B

Easy B is a simple tool to manage files uploaded to the BSV blockchain using the [b](https://github.com/unwriter/B)
protocol. It can be used as a CLI tool or as a libary inside nodejs.

## CLI

### Download a file

By default easy-b writes the content of the file to the standard output:

``` bash
easy-b read 2cfc649249aa845af21009d7bf8fe6f75f375f87e692ea7d92c3b3ac3d6583cb > my-audio.mp3
```

You can also specify an output file:

``` bash
easy-b read 2cfc649249aa845af21009d7bf8fe6f75f375f87e692ea7d92c3b3ac3d6583cb --output=my-audio.mp3
```

If you instead specify a directory easy-b is going to try to deduce te name of the file using the metadata of the B upload.

``` bash
easy-b read 2cfc649249aa845af21009d7bf8fe6f75f375f87e692ea7d92c3b3ac3d6583cb --output=~/Downloads
ls ~/Downloads # sample-3s.mp3
```

### Publish a file

In order to publish a file it's necesary to provide a private key with funds in WIF format. There are 2 ways to specify the key, using an env variable or as an option in the cli

``` bash 
export PURSE_WIF=<key>
easy-b publish path/to/file.png 
```

or

``` bash
easy-b --purse=<key> publish path/to/file.png 
```

### Specifying network

Easy-b works with mainnet and testnet.

``` bash
easy-b publish ./my-image.png --network=test
```

## Using inside nodejs

Publish:

``` js
const { BFile, publish, networks } = require('@runonbitcoin/easy-b') 

const purse = process.env.PURSE_WIF

const main = async () => {
  const bFile = await BFile.fromFilePath('/home/migue/Pictures/dragon.png')
  const txid = await publish(bFile, networks.MAINNET, purse)
  console.log(txid)
}

main()
```

Read:

``` js
const { BFile, read, networks } = require('@runonbitcoin/easy-b') 

const txid = '92b00456e0072ad51a97fe6ff31ba59079128529cb5b247eea5588610cb3d493'

const main = async () => {
  const bFile = await read(txid)
  console.log(bFile.mime)
  console.log(bFile.fileName)
  console.log(bFile.format)
  console.log(bFile.buff.toString('hex'))
}

main()
```
npm package: @runonflux/bitgo-ecpair
Description: Fork of ecpair with BitGo and Zelcore specific changes
Latest version: 1.0.1

# ecpair
[![Github CI](https://github.com/bitcoinjs/ecpair/actions/workflows/main_ci.yml/badge.svg)](https://github.com/bitcoinjs/ecpair/actions/workflows/main_ci.yml) [![NPM](https://img.shields.io/npm/v/ecpair.svg)](https://www.npmjs.org/package/ecpair) [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)

A library for managing SECP256k1 keypairs written in TypeScript with transpiled JavaScript committed to git.

This BitGo fork improves compatibility with fork coins, and alternative SECP256K1 implementations.

## Example

TypeScript

``` typescript
import { Signer, SignerAsync, ECPairInterface, ECPairFactory, ECPairAPI, TinySecp256k1Interface } from 'ecpair';
import * as crypto from 'crypto';

// You need to provide the ECC library. The ECC library must implement 
// all the methods of the `TinySecp256k1Interface` interface.
const tinysecp: TinySecp256k1Interface = require('tiny-secp256k1');
const ECPair: ECPairAPI = ECPairFactory(tinysecp);

// You don't need to explicitly write ECPairInterface, but just to show
// that the keyPair implements the interface this example includes it.

// From WIF
const keyPair1: ECPairInterface = ECPair.fromWIF('KynD8ZKdViVo5W82oyxvE18BbG6nZPVQ8Td8hYbwU94RmyUALUik');
// Random private key
const keyPair2 = ECPair.fromPrivateKey(crypto.randomBytes(32));
// OR (uses randombytes library, compatible with browser)
const keyPair3 = ECPair.makeRandom();
// OR use your own custom random buffer generator BE CAREFUL!!!!
const customRandomBufferFunc = (size: number): Buffer => crypto.randomBytes(size);
const keyPair4 = ECPair.makeRandom({ rng: customRandomBufferFunc });
// From pubkey (33 or 65 byte DER format public key)
const keyPair5 = ECPair.fromPublicKey(keyPair1.publicKey);

// Pass a custom network
const network = {}; // Your custom network object here
ECPair.makeRandom({ network });
ECPair.fromPrivateKey(crypto.randomBytes(32), { network });
ECPair.fromPublicKey(keyPair1.publicKey, { network });
// fromWIF will check the WIF version against the network you pass in
// pass in multiple networks if you are not sure
ECPair.fromWIF('wif key...', network);
const network2 = {}; // Your custom network object here
const network3 = {}; // Your custom network object here
ECPair.fromWIF('wif key...', [network, network2, network3]);
```

## LICENSE [MIT](LICENSE)
Written and tested by [bitcoinjs-lib](https://github.com/bitcoinjs/bitcoinjs-lib) contributors since 2014.
npm package: @runonflux/bitgo-utxo-lib
Description: Client-side Bitcoin JavaScript library
Author: BitGo SDK Team
Latest version: 9.37.3

This library is a fork from https://github.com/BitGo/BitGoJS/tree/master/modules/utxo-lib.

# BitGo UTXO library

This library is a wrapper around [bitcoinjs-lib](https://github.com/bitcoinjs/bitcoinjs-lib) adding altcoin support.

## Features

- Multicoin support: Configurable behaviour based on [network](https://github.com/BitGo/bitgo-utxo-lib/blob/master/src/networks.js) objects.
- Backed by [BitGo](https://www.bitgo.com/info/)

## Installation

```bash
# using npm
npm install @bitgo/utxo-lib

# using yarn
yarn add @bitgo/utxo-lib
```

## Setup

JavaScript (ESM)

```javascript
import * as utxolib from '@bitgo/utxo-lib';
```

NodeJS (CJS)

```javascript
const utxolib = require('@bitgo/utxo-lib');
```

## Usage

Support for parsing and building altcoin transactions is provided by the following methods

```typescript
utxolib.bitgo.createTransactionFromBuffer(buffer, network): UtxoTransaction
// (similarly `createTransactionFromHex(string, network)`)

utxolib.bitgo.createTransactionBuilderForNetwork(network): UtxoTransactionBuilder

utxolib.bitgo.createTransactionBuilderFromTransaction(tx): UtxoTransactionBuilder
```

The `UtxoTransaction(Builder)` classes have the same interface as the `Transaction` type in `bitcoinjs-lib` .

## Supported coins

| Network                     | Mainnet                        | Testnet                               |
| --------------------------- | ------------------------------ | ------------------------------------- |
| Bitcoin                     | `utxolib.networks.bitcoin`     | `utxolib.networks.testnet`            |
| Bitcoin Cash                | `utxolib.networks.bitcoincash` | `utxolib.networks.bitcoincashTestnet` |
| Bitcoin Gold                | `utxolib.networks.bitcoingold` | `utxolib.networks.bitcoingoldTestnet` |
| Bitcoin SV (Satoshi Vision) | `utxolib.networks.bitcoinsv`   | `utxolib.networks.bitcoinsvTestnet`   |
| Dash                        | `utxolib.networks.dash`        | `utxolib.networks.dash`               |
| eCash                       | `utxolib.networks.ecash`       | `utxolib.networks.ecashTestnet`       |
| Litecoin                    | `utxolib.networks.litecoin`    | `utxolib.networks.litecoinTest`       |
| Zcash                       | `utxolib.networks.zcash`       | `utxolib.networks.zcashTest`          |

> [Bitcoin SV](https://blog.bitgo.com/bsv-deprecation-6b3fff4df34c) no longer supports sending funds to BitGo wallets. Existing customers with Bitcoin SV in BitGo wallets will still be able to access and sweep funds to an external Bitcoin SV wallet.
npm package: @runonflux/groestl-hash-js
Description: groestl javascript hashing algorithm in pure javascript
Author: quantumexplorer
Latest version: 1.0.2

# groestl-hash-js

> Performs the groestl hash.

## Installation
```
$ npm install --save groestl-hash-js
```

## Usage

```js
var groestl = require('groestl-hash-js');

groestl.groestl512('The great experiment continues.');
// -> '6cea044acf31194eab7d1adb704712c34dd4f0b6a470b0f297832addab691faa459474c651efdbebddb138a2a9adb41705e0fb75741775314ddd8e5449ace986'

groestl.groestl('Groestl is an Austrian dish, usually made of leftover potatoes and pork, cut into slice.');
// -> 'eefdf4c9d6b6fd53390049388de8974525b406206114a8885016aa3661965253'

groestl.groestl_2('Groestl is an Austrian dish, usually made of leftover potatoes and pork, cut into slice.');
// -> '55415989225c5c902f5003679a98fac117555890a7c3119ab1d570c89e77b072'

```

## API

### groestl512(str[,input,output])

#### str

Type: `string`

Get the groestl hash (512 bit output) as `string` (output 0), a 8 bit `array` (output 1), a 32 bit `array` (output 2).

### groestl(str[,input,output])

#### str

Type: `string` (input 0), 8 bit `array` (input 1), 32 bit `array` (input 2)

Get the groestl hash (256 bit output) as `string` (output 0), a 8 bit `array` (output 1), a 32 bit `array` (output 2).

### groestl_2(str[,input,output])

#### str

Type: `string` (input 0), 8 bit `array` (input 1), 32 bit `array` (input 2)

Get the groestl hash (256 bit output) as `string` (output 0), a 8 bit `array` (output 1), a 32 bit `array` (output 2).
npm package: @runonflux/nat-upnp
Description: Port mapping via UPnP APIs
Author: Fedor Indutny
Latest version: 1.0.2

# NAT UPnP

Port mapping via UPnP APIs

## Installation

```bash
npm i @runonflux/nat-upnp
```

## Usage

```javascript
// using ES modules
import { Client } from "@runonflux/nat-upnp";
const client = new Client();

// using node require
const natUpnp = require("@runonflux/nat-upnp");
const client = new natUpnp.Client();

client
  .createMapping({
    public: 12345,
    private: 54321,
    ttl: 10,
  })
  .then(() => {
    // Will be called once finished
  })
  .catch(() => {
    // Will be called on error
  });

async () => {
  await client.removeMapping({
    public: 12345,
  });
};

client.getMappings();

client.getMappings({
  local: true,
  description: "both of these fields are optional",
});

client.getPublicIp();
```

### License

This software is licensed under the MIT License.

Copyright Fedor Indutny, 2012.

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to the
following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
USE OR OTHER DEALINGS IN THE SOFTWARE.
npm package: @runonflux/zelcorejs
Description: ZelCore JavaScript based library. Basic address and transaction construction for various cryptocurrencies.
Author: Tadeas Kmenta
Latest version: 2.14.0

# zelcorejs
Dead simple and easy to use JavaScript library for ZelCore purposes. Based on [zencashjs](https://github.com/ZencashOfficial/zencashjs)

# Getting started (Dev)
```bash
git clone https://github.com/zelcash/zelcorejs.git
cd zeltrzejs
npm install
```

# Example usage - more in tests
```javascript
var zelcorejs = require('zelcorejs')

var priv = zelcorejs.address.mkPrivKey('chris p. bacon, defender of the guardians')
// 2c3a48576fe6e8a466e78cd2957c9dc62128135540bbea0685d7c4a23ea35a6c

var wif = '80'

var privWIF = zelcorejs.address.privKeyToWIF(priv, true, wif)
// 5J9mKPd531Tk4A73kKp4iowoi6EvhEp8QSMAVzrZhuzZkdpYbK8

var pubKey = zelcorejs.address.privKeyToPubKey(priv, true)
// 048a789e0910b6aa314f63d2cc666bd44fa4b71d7397cb5466902dc594c1a0a0d2e4d234528ff87b83f971ab2b12cd2939ff33c7846716827a5b0e8233049d8aad

var pubKeyHash = '1cb8'

var tAddr = zelcorejs.address.pubKeyToAddr(pubKey, pubKeyHash)
// t1aYp69J595Rhaof2AEFuEvJjLWVboddB2x
```
npm package: @runopencode/fed-boilerplate
Description: Boilerplate code for front end development that is commonly used by RunOpenCode guys.
Author: Nikola Svitlica a.k.a TheCelavi
Latest version: 1.0.1

FED Boilerplate
===============

This is collection of commonly used CSS/JS snippets in RunOpenCode projects
that are missing in widely used libraries (e.g. Bootstrap).

## Quick start

- Install with [npm](https://www.npmjs.com/): `npm install @runopencode/fed-boilerplate`

## What's included

Within the download you'll find the following directories and files, compiled and minified variations. You'll see something like this:

```
fed-boilerplate/
└── dist/
    └── css/
        ├── fed-boilerplate.css
        └── fed-boilerplate.min.css
```

## Documentation

### CSS

All css classes using same naming as Bootstrap 3 classes

* **-xs** for extra small devices (less than 768px), this is default and no media query is used 
* **-sm** for small devices (768px and up)
* **-md** for medium devices (992px and up)
* **-lg** for large devices (1200px and up)

there are also classes with _'only'_ suffix - currently can be applied only to clearfix classes

* **-xs-only** only for extra small devices (up to 768px) 
* **-sm-only** only for small devices (from 768px up to 992px)
* **-md-only** only for medium devices (from 992px up to 1200px)
* **-lg-only** only for large devices (1200px and up)

#### Display

``` .display-block ``` 

``` .display-inline-block ```

``` .display-inline ```   

#### Floating

``` .pull-left ``` 

``` .pull-right ```

``` .pull-none ```

#### Margins and padding

###### Margins

Margins can be set to positive and negative values, default classes for margins and padding 
are from 0 to 20px 

eg. ```.ml-xs-10``` is ```margin-left: 10;``` and ```.ml-xs--10``` is ```margin-left: -10px;```

``` .m ```

``` .ml ```

``` .mr ```

``` .mt ```

``` .mb ```

###### Padding

Default classes for padding are from 0 to 20px

``` .p ```

``` .pl ```

``` .pr ```

``` .pt ```

``` .pb ```

#### Text

``` .text-center ```

``` .text-left ```

``` .text-right ```

``` .text-justify ```

#### Clearfix

``` .clearfix ```