open-index/open-npm huggingface dataset:
npm package: @luminati-io/gif
Description: Default Jimp gif encoder/decoder.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/gif</h1>
  <p>Default Jimp gif decoder.</p>
</div>

NOTE: Encoder currently unavailable.
npm package: @luminati-io/http-parser-js
Description: A pure JS HTTP parser for node.
Author: Tim Caswell
Latest version: 0.5.3-lum.0
Deprecated: false

# HTTP Parser

This library parses HTTP protocol for requests and responses.  It was created to replace `http_parser.c` since calling C++ function from JS is really slow in V8.  However, it is now primarily useful in having a more flexible/tolerant HTTP parser when dealing with legacy services that do not meet the strict HTTP parsing rules Node's parser follows.

This is packaged as a standalone npm module.  To use in node, monkeypatch HTTPParser.

```js
// Monkey patch before you require http for the first time.
process.binding('http_parser').HTTPParser = require('http-parser-js').HTTPParser;

var http = require('http');
// ...
```

## Testing

Simply do `npm test`. The tests are copied from node and mscedex/io.js, with some modifcations.

## Status

This should now be usable in any node application, it now supports (nearly) everything `http_parser.c` does while still being tolerant with corrupted headers, and other kinds of malformed data.

### Node Versions

`http-parser-js` should work via monkey-patching on Node v6-v11, and v13.

Node v12.x renamed the internal http parser, and did not expose it for monkey-patching, so to be able to monkey-patch on Node v12, you must run `node --http-parser=legacy file.js` to opt in to the old, monkey-patchable http_parser binding.

## License

MIT. See LICENSE.md
npm package: @luminati-io/http-signature
Description: Reference implementation of Joyent's HTTP Signature scheme.
Author: Joyent, Inc
Latest version: 1.1.1-lum.1

# node-http-signature

node-http-signature is a node.js library that has client and server components
for Joyent's [HTTP Signature Scheme](http_signing.md).

## Usage

Note the example below signs a request with the same key/cert used to start an
HTTP server. This is almost certainly not what you actually want, but is just
used to illustrate the API calls; you will need to provide your own key
management in addition to this library.

### Client

```js
var fs = require('fs');
var https = require('https');
var httpSignature = require('http-signature');

var key = fs.readFileSync('./key.pem', 'ascii');

var options = {
  host: 'localhost',
  port: 8443,
  path: '/',
  method: 'GET',
  headers: {}
};

// Adds a 'Date' header in, signs it, and adds the
// 'Authorization' header in.
var req = https.request(options, function(res) {
  console.log(res.statusCode);
});


httpSignature.sign(req, {
  key: key,
  keyId: './cert.pem'
});

req.end();
```

### Server

```js
var fs = require('fs');
var https = require('https');
var httpSignature = require('http-signature');

var options = {
  key: fs.readFileSync('./key.pem'),
  cert: fs.readFileSync('./cert.pem')
};

https.createServer(options, function (req, res) {
  var rc = 200;
  var parsed = httpSignature.parseRequest(req);
  var pub = fs.readFileSync(parsed.keyId, 'ascii');
  if (!httpSignature.verifySignature(parsed, pub))
    rc = 401;

  res.writeHead(rc);
  res.end();
}).listen(8443);
```

## Installation

    npm install http-signature

## License

MIT.

## Bugs

See <https://github.com/joyent/node-http-signature/issues>.
npm package: @luminati-io/jpeg
Description: Default Jimp jpeg encoder/decoder.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/jpeg</h1>
  <p>Default Jimp jpeg encoder/decoder.</p>
</div>

## Available Methods

### Jimp.quality

Sets the quality of the image when saving as JPEG format (default is 100)
npm package: @luminati-io/knex-snowflake-dialect
Description: knex.js dialect for the Snowflake data warehouse
Author: Emmet Murphy
Latest version: 1.0.3-lum.17

# knex-snowflake-dialect
knex.js dialect for the Snowflake data warehouse.

As of release 0.2.x, the `connect` and `raw` query methods have been tested, along with schema migrations.

## Installation

```shell script
npm install knex-snowflake-dialect
```

## Usage

Sample initialization:

```javascript
import * as knex from "knex";
import { SnowflakeDialect } from "knex-snowflake-dialect";

export const Snowflake = knex({
  client: SnowflakeDialect,
  debug: true,
  connection: "snowflake://myuser:mypassword@myaccount.myregion.snowflakecomputing.com/mydb?warehouse=MY_WAREHOUSE",
  pool: {
    min: 1,
    max: 1
  }
});
```

The configuration could alternatively break out the `connection` parameters as separate keys, per the 
[snowflake-sdk "Establishing a Connection"](https://docs.snowflake.net/manuals/user-guide/nodejs-driver-use.html#establishing-a-connection)
documentation.
npm package: @luminati-io/kubernetes-models-rabbitmq-cluster-operator
Description: The RabbitMQ Cluster Kubernetes Operator automates provisioning, management, and operations of RabbitMQ clusters running on Kubernetes.
Author: Justin Chen
Latest version: 2.7.0-brd.0

# @kubernetes-models/rabbitmq-cluster-operator

[RabbitMQ Cluster Operator](https://github.com/rabbitmq/cluster-operator) models.

## Installation

Install with npm.

```sh
npm install @kubernetes-models/rabbitmq-cluster-operator
```

## Usage

```js
import { RabbitmqCluster } from "@kubernetes-models/rabbitmq-cluster-operator/rabbitmq.com/v1beta1/RabbitmqCluster";

// Create a new RabbitmqCluster
const cluster = new RabbitmqCluster({
  metadata: { name: "example" },
  spec: {
    replicas: 3,
    service: {
      type: "LoadBalancer"
    }
  }
});

// Validate against JSON schema
cluster.validate();
```

## License

See [LICENSE](../../LICENSE)
npm package: @luminati-io/lodash4
Description: Lodash modular utilities.
Author: John-David Dalton
Latest version: 4.17.21

# lodash v4.17.21

The [Lodash](https://lodash.com/) library exported as [Node.js](https://nodejs.org/) modules.

## Installation

Using npm:
```shell
$ npm i -g npm
$ npm i --save lodash
```

In Node.js:
```js
// Load the full build.
var _ = require('lodash');
// Load the core build.
var _ = require('lodash/core');
// Load the FP build for immutable auto-curried iteratee-first data-last methods.
var fp = require('lodash/fp');

// Load method categories.
var array = require('lodash/array');
var object = require('lodash/fp/object');

// Cherry-pick methods for smaller browserify/rollup/webpack bundles.
var at = require('lodash/at');
var curryN = require('lodash/fp/curryN');
```

See the [package source](https://github.com/lodash/lodash/tree/4.17.21-npm) for more details.

**Note:**<br>
Install [n_](https://www.npmjs.com/package/n_) for Lodash use in the Node.js < 6 REPL.

## Support

Tested in Chrome 74-75, Firefox 66-67, IE 11, Edge 18, Safari 11-12, & Node.js 8-12.<br>
Automated [browser](https://saucelabs.com/u/lodash) & [CI](https://travis-ci.org/lodash/lodash/) test runs are available.
npm package: @luminati-io/mocha
Description: simple, flexible, fun test framework
Author: TJ Holowaychuk
Latest version: 2.4.2-lum.2

[![Build Status](https://api.travis-ci.org/mochajs/mocha.svg?branch=master)](http://travis-ci.org/mochajs/mocha) [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/mochajs/mocha?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)

  [![Mocha test framework](http://f.cl.ly/items/3l1k0n2A1U3M1I1L210p/Screen%20Shot%202012-02-24%20at%202.21.43%20PM.png)](http://mochajs.org)

  Mocha is a simple, flexible, fun JavaScript test framework for node.js and the browser. For more information view the [documentation](http://mochajs.org).

## Links

  - [Changelog](https://github.com/mochajs/mocha/blob/master/CHANGELOG.md)
  - [Google Group](http://groups.google.com/group/mochajs)
  - [Wiki](https://github.com/mochajs/mocha/wiki)
  - Mocha [Extensions and reporters](https://github.com/mochajs/mocha/wiki)
npm package: @luminati-io/native-dns-packet
Description: Raw DNS Packet Parsing and Writing
Latest version: 0.1.1-lum.0
Deprecated: false

native-dns-packet
-----------------

 * `Packet.parse(buffer)` returns an instance of `Packet`
 * `Packet.write(buffer, packet)` writes the given packet into the buffer,
truncating where appropriate

```javascript
var Packet = function () {
  this.header = {
    id: 0,
    qr: 0,
    opcode: 0,
    aa: 0,
    tc: 0,
    rd: 1,
    ra: 0,
    res1: 0,
    res2: 0,
    res3: 0,
    rcode: 0
  };
  this.question = [];
  this.answer = [];
  this.authority = [];
  this.additional = [];
  this.edns_options = [];
  this.payload = undefined;
};
```

## History

###### 0.1.1 - October 5, 2014

- Fixing NPM tagging issue...

###### 0.1.0 - October 2, 2014

- Added TLSA support
- Fixed EDNS & NAPTR support + deprecates some EDNS fields on Packet
- Now includes support for forwarding EDNS responses (Packet.edns)
- Added many TODOs with suggested improvements
- Added many links to GH issues and RFCs
- Cleaned up code a bit to better please linters
- Added deprecation notices (see parseOpt)
- Handle unhandled RRs on writing packet instead of throwing exception.
- edns/opt should use BufferCursor.copy (Fixes #11)
- Updated `package.json` to include all authors
- Merged tj's `master` branch to add License info
- Updated README to include history of changes
npm package: @luminati-io/node-crypt3
Description: Node.js crypt(3) bindings
Author: Jaakko-Heikki Heusala
Latest version: 1.0.0-lum.1

node-crypt3
===========

[crypt3link]: https://en.wikipedia.org/wiki/Crypt_(C) "crypt() in C"

[crypt(3)][crypt3link] for Node.js

Installation
------------

Install using `npm install crypt3` and use:

```javascript
var crypt = require('crypt3');
```

Example password check
----------------------

```javascript
if( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', '$1$SrkubyRm$DEQU3KupUxt4yfhbK1HyV/') !== '$1$SrkubyRm$DEQU3KupUxt4yfhbK1HyV/' ) {
	console.error('Access denied!');
	return;
}
```

Example password encoding
-------------------------

Use `crypt(key[, salt])`:

```javascript
console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh') );                                   // Salt generated automatically using default SHA512
console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('md5') ) );         // MD5 salt
console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('blowfish') ) );    // Blowfish salt (only some Linux distros)
console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('sha256') ) );      // SHA-256
console.log( crypt('6Xz7sS6fEmnWScMb6Ayf363e5cdqF4Kh', crypt.createSalt('sha512') ) );      // SHA-512
```

Create hashes
-------------

Use `crypt.createSalt([type=sha512])` where type is one of `md5`, `blowfish`, `sha256` or `sha512` (default). 

Commercial Support
------------------

You can buy commercial support from [Sendanor](http://sendanor.com/software).
npm package: @luminati-io/node-unlisten
Description: Temporarily stop accepting connections on a TCP or HTTP(S) server
Author: Alexey Feldgendler
Latest version: 1.0.2-lum.4

# unlisten

```js
const unlisten = require('unlisten');
```

Node.js module: Temporarily stop accepting connections on a TCP or HTTP(S) server.

## Introduction

Once you get a `net.Server`, `http.Server` or `https.Server` in Node.js to
start listening on a port, they will automatically accept every connection that
comes their way. Node.js doesn't let you stop accepting temporarily without
tearing down the whole server (which involves closing the listening socket).

Why would you want to stop accepting?

If you're using `cluster.SCHED_NONE` instead of the default `cluster.SCHED_RR`
as Node.js' [scheduling policy](https://nodejs.org/api/cluster.html#cluster_cluster_schedulingpolicy),
your workers share the listening socket. When a new connection comes, all
workers that are currently blocked in `epoll_wait` wake up and race to accept
it; if none is in `epoll_wait`, the next one to call `epoll_wait` gets it. This
naturally excludes workers that are very busy. Still, other workers can bite more
than they can chew, especially given that the way the kernel seems to work, the
same worker tends to win the race every time.

So if the workers have some kind of safeguard against overload, such as the
[toobusy-js](https://www.npmjs.com/package/toobusy-js) module, they can do
better than just denying service: using the `unlisten` module, a worker can
temporarily stop participating in the accept race and let other, less busy
workers help out.

## Usage

To make an instance of `net.Server`, `http.Server` or `https.Server` stop
accepting connections:

```js
unlisten.pause(server);
```

To resume accepting:

```js
unlisten.resume(server);
```

The calls are idempotent (that means, calling `pause` or `resume` the second
time in a row on the same server does nothing).

This is only for listening servers! Don't try it on sockets that represent
established connections rather than servers, or on servers that haven't started
listening or have been closed.

## Limitations

* This module only works (and compiles) on Linux.
* In Node.js cluster workers, it requires `cluster.SCHED_NONE`.
* It fiddles with the `libuv` internals, and might stop working with future
  versions of Node.js. PRs to keep it compatible are welcome.
* The server instance must have already started listening.
npm package: @luminati-io/plugin-blit
Description: Blit an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-blit</h1>
  <p>Blit an image.</p>
</div>

> Blit - a data operation commonly used in computer graphics in which several bitmaps are combined into one using a boolean function.

## Usage

Blits a source image on to this image

- @param {Jimp} src image to blit
- @param {number} x the x position to blit the image
- @param {number} y the y position to blit the image
- @param {number} srcx (optional) the x position from which to crop the source image
- @param {number} srcy (optional) the y position from which to crop the source image
- @param {number} srcw (optional) the width to which to crop the source image
- @param {number} srch (optional) the height to which to crop the source image
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');
  const parrot = await jimp.read('test/party-parrot.png');

  image.blit(parrot, x, y);
}

main();
```
npm package: @luminati-io/plugin-blur
Description: blur an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-blur</h1>
  <p>Blur an image.</p>
</div>

A fast blur algorithm that produces similar effect to a Gaussian blur - but MUCH quicker

## Usage

- @param {number} r the pixel radius of the blur
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.blur(5);
}

main();
```
npm package: @luminati-io/plugin-circle
Description: Creates a circle out of an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-circle</h1>
  <p>Creates a circle out of an image.</p>
</div>

## Usage

- @param {function(Error, Jimp)} options (optional) radius, x, y
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.circle();
  // or
  image.circle({ radius: 50, x: 25, y: 25 });
}

main();
```
npm package: @luminati-io/plugin-contain
Description: contain an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-contain</h1>
  <p>Contain an image within a height and width.</p>
</div>

Scale the image to the given width and height keeping the aspect ratio. Some parts of the image may be letter boxed.

## Usage

- @param {number} w the width to resize the image to
- @param {number} h the height to resize the image to
- @param {number} alignBits (optional) A bitmask for horizontal and vertical alignment
- @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.contain(150, 100);
}

main();
```

### Align modes

The following constants can be passed to `image.contain`:

```js
Jimp.HORIZONTAL_ALIGN_LEFT;
Jimp.HORIZONTAL_ALIGN_CENTER;
Jimp.HORIZONTAL_ALIGN_RIGHT;

Jimp.VERTICAL_ALIGN_TOP;
Jimp.VERTICAL_ALIGN_MIDDLE;
Jimp.VERTICAL_ALIGN_BOTTOM;
```

For example:

```js
image.contain(250, 250, Jimp.HORIZONTAL_ALIGN_LEFT | Jimp.VERTICAL_ALIGN_TOP);
image.contain(
  250,
  250,
  Jimp.HORIZONTAL_ALIGN_RIGHT | Jimp.VERTICAL_ALIGN_BOTTOM
);
```

Default align mode for `image.contain` is:

```js
Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE;
```
npm package: @luminati-io/plugin-cover
Description: cover an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-cover</h1>
</div>

Scale the image so the given width and height keeping the aspect ratio. Some parts of the image may be clipped.

## Usage

- @param {number} w the width to resize the image to
- @param {number} h the height to resize the image to
- @param {number} alignBits (optional) A bitmask for horizontal and vertical alignment
- @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.cover(150, 100);
}

main();
```

### Align modes

The following constants can be passed to `image.cover`:

```js
Jimp.HORIZONTAL_ALIGN_LEFT;
Jimp.HORIZONTAL_ALIGN_CENTER;
Jimp.HORIZONTAL_ALIGN_RIGHT;

Jimp.VERTICAL_ALIGN_TOP;
Jimp.VERTICAL_ALIGN_MIDDLE;
Jimp.VERTICAL_ALIGN_BOTTOM;
```

For example:

```js
image.cover(250, 250, Jimp.HORIZONTAL_ALIGN_LEFT | Jimp.VERTICAL_ALIGN_TOP);
image.cover(250, 250, Jimp.HORIZONTAL_ALIGN_RIGHT | Jimp.VERTICAL_ALIGN_BOTTOM);
```

Default align mode for `image.cover` is:

```js
Jimp.HORIZONTAL_ALIGN_CENTER | Jimp.VERTICAL_ALIGN_MIDDLE;
```
npm package: @luminati-io/plugin-crop
Description: crop an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-crop</h1>
  <p>Crop an image.</p>
</div>

## Crop

Crops the image at a given point to a give size

- @param {number} x the x coordinate to crop form
- @param {number} y the y coordinate to crop form
- @param w the width of the crop region
- @param h the height of the crop region
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.crop(150, 150);
}

main();
```

## AutoCrop

AutoCrop same color borders from this image

- @param {number} tolerance (optional): a percent value of tolerance for pixels color difference (default: 0.0002%)
- @param {boolean} cropOnlyFrames (optional): flag to crop only real frames: all 4 sides of the image must have some border (default: true)

or

- @param {object} options object
  - tolerance (optional): a percent value of tolerance for pixels color difference (default: 0.0002%)
  - cropOnlyFrames (optional): flag to crop only real frames: all 4 sides of the image must have some border (default: true)
  - cropSymmetric (optional): flag to force cropping top be symmetric. north and south / east and west are cropped by the same value
  - leaveBorder (optional): integer of how many pixels of the background color to leave around the image

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.autocrop();
  image.autocrop({ cropOnlyFrames: false, cropSymmetric: true });
}

main();
```
npm package: @luminati-io/plugin-displace
Description: displace an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-displace</h1>
  <p>Displace an image.</p>
</div>

Displaces the image based on the provided displacement map

## Usage

- @param {object} map the source Jimp instance
- @param {number} offset the maximum displacement value
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  // Make me better!
  image.displace(map, 10);
}

main();
```
npm package: @luminati-io/plugin-dither
Description: Dither an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-dither</h1>
  <p>Apply a dither effect to an image.</p>
</div>

> Dither - is an intentionally applied form of noise used to randomize quantization error, preventing large-scale patterns such as color banding in images. Dither is routinely used in processing of both digital audio and video data, and is often one of the last stages of mastering audio to a CD.

## Usage

Apply a ordered dithering effect

- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.dither565();
}

main();
```
npm package: @luminati-io/plugin-fisheye
Description: Apply a fisheye effect to an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-fishey</h1>
  <p>Apply a fisheye effect to an image</p>
</div>

## Usage

- @param {function(Error, Jimp)} options (optional) radius
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.fisheye();
  // or
  image.fisheye({ r: 1.6 });
}

main();
```

Produces nice images with [@jimp/plugin-circle](../plugin-circle).
npm package: @luminati-io/plugin-flip
Description: flip an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-flip</h1>
  <p>flip an image.</p>
</div>

Flip the image horizontally or vertically. Defaults to horizontal.

Also aliased as `mirror`

## Usage

- @param {boolean} horizontal a Boolean, if true the image will be flipped horizontally
- @param {boolean} vertical a Boolean, if true the image will be flipped vertically
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.flip();
  image.mirror();
  image.flip(false, true);
}

main();
```
npm package: @luminati-io/plugin-gaussian
Description: gaussian blur an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-gaussian</h1>
  <p>Gaussian blur an image.</p>
</div>

Applies a true Gaussian blur to the image (warning: this is VERY slow)

## Usage

- @param {number} r the pixel radius of the blur
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.gaussian(15);
}

main();
```
npm package: @luminati-io/plugin-invert
Description: invert an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-invert</h1>
  <p>Invert an image's colors.</p>
</div>

Invert an image's colors.

## Usage

- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.invert();
}

main();
```
npm package: @luminati-io/plugin-mask
Description: mask an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-mask</h1>
  <p>mask an image with another image.</p>
</div>

Masks a source image on to this image using average pixel colour. A completely black pixel on the mask will turn a pixel in the image completely transparent.

## Usage

- @param {Jimp} src the source Jimp instance
- @param {number} x the horizontal position to blit the image
- @param {number} y the vertical position to blit the image
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');
  const mask = await jimp.read('test/mask.png');

  image.mask(mask);
}
```
npm package: @luminati-io/plugin-normalize
Description: normalize an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-normalize</h1>
  <p>Normalize an image's colors.</p>
</div>

Normalizes an images color by computing a histogram.

## Usage

- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.normalize();
}

main();
```
npm package: @luminati-io/plugin-resize
Description: Resize an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-resize</h1>
  <p>Resize an image.</p>
</div>

Resizes the image to a set width and height using a 2-pass bilinear algorithm/

## Usage

- @param {number} w the width to resize the image to (or Jimp.AUTO)
- @param {number} h the height to resize the image to (or Jimp.AUTO)
- @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
	// Read the image.
	const image = await jimp.read('test/image.png');

	// Resize the image to width 150 and auto height.
	await image.resize(150, jimp.AUTO);

	// Save and overwrite the image
	await image.writeAsync('test/image.png');
}

main();
```

## Auto

`Jimp.AUTO` can be passes to either the height or width and jimp will scale the image accordingly. `Jimp.AUTO` cannot be both height and width.

```js
// resize the height to 250 and scale the width accordingly
image.resize(Jimp.AUTO, 250);
// resize the width to 250 and scale the height accordingly
image.resize(250, Jimp.AUTO);
```

### Resize modes

The default resizing algorithm uses a bilinear method.

Optionally, the following constants can be passed to choose a particular resizing algorithm:

```js
Jimp.RESIZE_NEAREST_NEIGHBOR;
Jimp.RESIZE_BILINEAR;
Jimp.RESIZE_BICUBIC;
Jimp.RESIZE_HERMITE;
Jimp.RESIZE_BEZIER;
```

```js
image.resize(250, 250, Jimp.RESIZE_BEZIER);
```
npm package: @luminati-io/plugin-rotate
Description: Rotate an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-rotate</h1>
  <p>Rotate an image.</p>
</div>

Rotates the image clockwise by a number of degrees. By default the width and height of the image will be resized appropriately.

## Usage

- @param {number} deg the number of degrees to rotate the image by
- @param {string|boolean} mode (optional) resize mode or a boolean, if false then the width and height of the image will not be changed
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.rotate(90);
}

main();
```
npm package: @luminati-io/plugin-scale
Description: scale an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-scale</h1>
  <p>Scale an image.</p>
</div>

## scale

Uniformly scales the image by a factor.

- @param {number} f the factor to scale the image by
- @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.scale(2);
  image.scale(2, jimp.RESIZE_BEZIER);
}

main();
```

## scaleToFit

Scale the image to the largest size that fits inside the rectangle that has the given width and height.

- @param {number} w the width to resize the image to
- @param {number} h the height to resize the image to
- @param {string} mode (optional) a scaling method (e.g. Jimp.RESIZE_BEZIER)
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.scaleToFit(100, 100);
}

main();
```
npm package: @luminati-io/plugin-shadow
Description: Creates a shadow on an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-shadow</h1>
  <p>Creates a shadow on an image.</p>
</div>

## Usage

- @param {function(Error, Jimp)} options (optional)
  - opacity - opacity of the shadow between 0 and 1
  - size,- of the shadow
  - blur - how blurry the shadow is
  - x - x position of shadow
  - y - y position of shadow
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.shadow();
  // or
  image.shadow({ opacity: 0.8, size: 1.2, blur: 10, x: -75, y: -75 });
}

main();
```
npm package: @luminati-io/plugin-threshold
Description: Lightens an image.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugin-threshold</h1>
  <p>Lightens an image.</p>
</div>

This is useful as a simplified method for processing scanned drawings, signatures, etc

## Usage

- @param {number} options object
  - max: A number auto limited between 0 - 255
  - replace: (optional) A number auto limited between 0 - 255 (default 255)
  - autoGreyscale: (optional) A boolean whether to apply greyscale beforehand (default true)
- @param {function(Error, Jimp)} cb (optional) a callback for when complete

```js
import jimp from 'jimp';

async function main() {
  const image = await jimp.read('test/image.png');

  image.threshold({ max: 150 });
  // or
  image.threshold({ max: 200, replace: 200, autoGreyscale: false });
}

main();
```
npm package: @luminati-io/plugins
Description: Default Jimp plugin.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/plugins</h1>
  <p>Default Jimp plugins.</p>
</div>

## Included Plugins

- [blit](../plugin-blit)
- [blur](../plugin-blur)
- [color](../plugin-color)
- [contain](../plugin-contain)
- [cover](../plugin-cover)
- [displace](../plugin-displace)
- [dither](../plugin-dither)
- [flip](../plugin-flip)
- [gaussian](../plugin-gaussian)
- [invert](../plugin-invert)
- [mask](../plugin-mask)
- [normalize](../plugin-normalize)
- [print](../plugin-print)
- [resize](../plugin-resize)
- [rotate](../plugin-rotate)
- [scale](../plugin-scale)
npm package: @luminati-io/png
Description: Default Jimp png encoder/decoder.
Latest version: 0.16.1-lum.3

<div align="center">
  <img width="200" height="200"
    src="https://s3.amazonaws.com/pix.iemoji.com/images/emoji/apple/ios-11/256/crayon.png">
  <h1>@jimp/png</h1>
  <p>Default Jimp png encoder/decoder.</p>
</div>

## Available Methods

### Jimp.deflateLevel

Sets the deflate level used when saving as PNG format (default is 9)

### Jimp.deflateStrategy

Sets the deflate strategy used when saving as PNG format (default is 3)

### Jimp.filterType

Sets the filter type used when saving as PNG format (default is automatic filters)

### Jimp.colorType

Sets the color type used when saving as PNG format (one of 0, 2, 4, 6)

### Filter Types

```js
Jimp.PNG_FILTER_AUTO;
Jimp.PNG_FILTER_NONE;
Jimp.PNG_FILTER_SUB;
Jimp.PNG_FILTER_UP;
Jimp.PNG_FILTER_AVERAGE;
Jimp.PNG_FILTER_PATH;
```