open-index/open-npm huggingface dataset:
npm package: @plex-inc/icons
Description: Plex icons
Latest version: 1.0.1

```ascii
██████╗ ██╗     ███████╗██╗  ██╗
██╔══██╗██║     ██╔════╝╚██╗██╔╝
██████╔╝██║     █████╗   ╚███╔╝ 
██╔═══╝ ██║     ██╔══╝   ██╔██╗ 
██║     ███████╗███████╗██╔╝ ██╗
╚═╝     ╚══════╝╚══════╝╚═╝  ╚═╝
```

# @plex-inc/icons

## Installation

You can install this package using npm. Make sure React is already installed in your project.

```bash
npm install @plex-inc/icons
```

## Usage

After installing the package:

```tsx
    import { IconFill } from '@plex-inc/icons'

    <IconFill size={16} />
```
npm package: @plex-inc/tg-notifier
Description: A library for sending messages to Telegram chats
Author: Denis Voropaev
Latest version: 1.1.3

# tg-notifier

`tg-notifier` is a library for sending messages to Telegram chats using your bot, built with Node.js and TypeScript. It supports sending messages to multiple chats simultaneously and provides logging for successful and failed operations.

## Installation

To install the library, use npm:

```bash
npm install tg-notifier
```

## Usage

### Creating an Instance of `TgNotifier`

To use the `TgNotifier` library, you first need to create an instance of the `TgNotifier` class. You can configure it with your bot token, default chat ID, and other optional settings.

```typescript
import { TgNotifier } from 'tg-notifier';

const notifier = new TgNotifier({
  token: 'YOUR_BOT_TOKEN',
  chatId: 'YOUR_CHAT_ID', // Optional: Default chat ID to use if not specified in the sendMessage method
  logsDir: 'path/to/logs', // Optional: Directory for logs
  cleanIntervalHours: 24, // Optional: Interval in hours for cleaning old logs (default is 24 hours)
  chatIdsFile: 'chat_ids.txt' // Optional: File to store chat IDs
});
```

## Sending a Message

To send a message using the `TgNotifier` library, you have two main methods: `sendMessage` for sending to a specific chat and `sendToMultipleChats` for sending to multiple chats.

### Sending a Message to a Single Chat

Use the `sendMessage` method to send an HTML-formatted message to a specific chat. Provide the message content and the chat ID as parameters.

```typescript
await notifier.sendMessage('<b>Bold text</b> and <i>italic text</i>', 'CHAT_ID');
```

### Sending a Message to Multiple Chats

If you want to send a message to multiple chats at once, use the `sendToMultipleChats` method. Provide the message and an array of chat IDs.

```typescript
const chatIds = ['CHAT_ID_1', 'CHAT_ID_2'];
await notifier.sendToMultipleChats('<b>Bold text</b> and <i>italic text</i>', chatIds);
```
npm package: @plexidev/teris
Description: A stripped down version of Eris (https://abal.moe/Eris) that supports native redis caching for users and members.
Author: abalabahaha, Zoro
Latest version: 0.11.5-alpine

Eris [![NPM version](https://img.shields.io/npm/v/eris.svg?style=flat-square)](https://npmjs.com/package/eris)
====

A NodeJS wrapper for interfacing with Discord.

Installing
----------

You will need NodeJS 8+. If you need voice support you will also need Python 2.7 and a C++ compiler. Refer to [the Getting Started section of the docs](https://abal.moe/Eris/docs.html) for more details.

```
npm install --no-optional eris
```

If you need voice support, remove the `--no-optional`

Ping Pong Example
-----------------

```js
const Eris = require("eris");

var bot = new Eris("BOT_TOKEN");
// Replace BOT_TOKEN with your bot account's token

bot.on("ready", () => { // When the bot is ready
    console.log("Ready!"); // Log "Ready!"
});

bot.on("messageCreate", (msg) => { // When a message is created
    if(msg.content === "!ping") { // If the message content is "!ping"
        bot.createMessage(msg.channel.id, "Pong!");
        // Send a message in the same channel with "Pong!"
    } else if(msg.content === "!pong") { // Otherwise, if the message is "!pong"
        bot.createMessage(msg.channel.id, "Ping!");
        // Respond with "Ping!"
    }
});

bot.connect(); // Get the bot to connect to Discord
```

More examples can be found in [the examples folder](https://github.com/abalabahaha/eris/tree/master/examples).

Useful Links
------------

[The website](https://abal.moe/Eris) includes more detailed information on getting started, as well as documentation for the different components.

[The Discord API channel (#js_eris)](https://abal.moe/Eris/invite) is the best place to get support/contact me.

[The GitHub repo](https://github.com/abalabahaha/eris) has the most updated code.

[The NPM package](https://npmjs.com/package/eris)

License
-------

Refer to the [LICENSE](LICENSE) file.
npm package: @plexinc/react-lightning-plugin-devtools
Description: React-Lightning DevTools for Chromium-based browsers
Author: Plex Inc.
Latest version: 0.1.6

# Building

- `pnpm install`
- `pnpm build`

This will create the files needed for the extension in the `dist` folder.

`pnpm dev` will watch for changes and re-build.

# Usage

### Integrating into your react-lightning app

Import the plugin:

`import devtoolsPlugin from '@plexinc/react-lightning-plugin-devtools/plugin'`

Include the options in the react-lightning render options:

```
const options: RenderOptions = {
  // ... other options
  plugins: [devtoolsPlugin(), /* other plugins */],
};
```

### Adding devtools to Chrome

- Go to our Chrome extensions settings
- Enable `Developer mode`
- Select `Load unpacked`
- Navigate to the `dist` folder created from the build
- Open devtools and you should see a `React Lightning` panel

Note: During development, any changes to the entrypoint files or manifest may require
restarting devtools or sometimes even a reload of the extension if you don't see
your changes.
npm package: @plexis/cache
Description: A caching mechanism for string operations. 
Latest version: 0.0.22

## `@plexis/cache`

A caching mechanism for string operations.

`npm i @plexis/cache`

**Usage**

```javascript
import cache from '@plexis/cache';

const toLower = x => x.toLowerCase();
const toLowerCache = cache(toLower);

// We are adding a dummy resolver function which returns the same cache every single time
const toLowerCacheWithResolver = cache(toLower, x => 'a');

toLowerCache('A'); // returns a;
toLowerCache('B'); // returns b;

toLowerCacheWithResolver('A'); // returns a;
toLowerCacheWithResolver('B'); // returns a !!;
```

**Aliases**

```javascript
import cache from '@plexis/cache';
import {cache, memoize} from 'plexis';
```
npm package: @plexis/compare
Description: Compares input text as humans do.
Author: Brandon Skinner
Latest version: 0.0.22

## `compare`

Compares input text as humans do.

`npm i @plexis/compare`

**Usage**

```javascript
import naturalCompare from '@plexis/compare';

compare('A', 'b'); // returns 1
compare('A woman', 'a woman'); // returns 1
compare('b', 'B'); // returns -1
```

**Aliases**

```javascript
import compare from '@plexis/compare';
import {compare, compareLikeHuman, naturalCompare} from 'plexis';
```
npm package: @plexis/compose
Description: Compose 2 or more functions.
Latest version: 0.0.22

# `@plexis/compose`

Compose 2 or more functions.

**Installation**
`npm i @plexis/compose`

**Usage**

```javascript
import compose from '@plexis/compose';
const inc = x => x + 1;
const add = (x, y) => x + y;
const ops = compose(
  inc,
  x => add(x, 2)
);

ops(1); // returns 4;
ops(10); // returns 13;
```

**Aliases**

```javascript
import compose from '@plexis/compose';
import {compose, _do} from 'plexis';
```
npm package: @plexis/count
Description: Return the number of characters in the input text.
Author: Angel Gonzalez
Latest version: 0.0.22

## `@plexis/count`

Return the number of characters in the input text.

`npm i @plexis/count`

**Usage**

```javascript
import count from '@plexis/count';

count(); // returns 0
count(''); // returns 0
count('Hello'); // returns 5
count('Hello   '); // returns 8
count('Hello   ', char => char !== ' '); // returns 5
```

**Aliases**

```javascript
import count from '@plexis/count';
import {count} from 'plexis';
```
npm package: @plexis/distance
Description: Calculates the [Levenshtein Distance](https://en.wikipedia.org/wiki/Levenshtein_distance) between two strings.
Author: Brandon Skinner
Latest version: 0.0.22

## `distance`

Calculates the [Levenshtein Distance](https://en.wikipedia.org/wiki/Levenshtein_distance) between two strings.

`npm i @plexis/distance`

**Usage**

```javascript
import distance from '@plexis/distance';
distance('book', 'back'); // returns 2
distance('black', 'back'); // returns 1
distance('Foo', 'Bar'); // returns 3
```

**Aliases**

```javascript
import distance from '@plexis/distance';
import {distance, calcLevenshtein, levenshtein} from 'plexis';
```
npm package: @plexis/ends-with
Description: Checks whether the input text ends with the given pattern
Latest version: 0.0.22

# `endsWith`

Checks whether the input text ends with the given pattern

`npm i @plexis/ends-with`

## Usage

```javascript
import endsWith from '@plexis/ends-with';

const txt = 'This is me';

endsWith(txt, 'is me'); // true
endsWith(txt, 'is m', txt.length - 1); // true
endsWith(txt, 'is m', txt.length); // false
endsWith(txt, 'Foo'); // false
```
npm package: @plexis/escape-html
Description: Takes the input text and converts HTML special characters to their entity equivalents.
Latest version: 0.0.22

# `@plexis/escapeHTML`

Takes the input text and converts HTML special characters to their entity equivalents.

**Installation**
`npm i @plexis/escape-html`

**Usage**

```javascript
import escapeHTML from '@plexis/escape-html';

escapeHTML('ABCD'); // returns 'ABCD'
escapeHtml('<3'); // returns '&lt;3'
escapeHtml('<p>This is cool</p>'); // returns '&lt;p&gt;This is cool&lt;/p&gt;'
```

**Aliases**

```javascript
import {escapeHTML} from 'plexis';
```
npm package: @plexis/head
Description: Extracts the first length characters from the input text.
Latest version: 0.0.22

## `head`

Extracts the first length characters from the input text.

`npm i @plexis/head`

**Usage**

```javascript
import head from '@plexis/head';

head(); // => ''
head('Hello'); // => 'H'
head('Hello', 2); // => 'He'
head('Hello', 100); // => 'Hello'
```

**Aliases**

```javascript
import {head} from 'plexis';
import {first} from 'plexis';
import {popFirst} from 'plexis';
```
npm package: @plexis/includes
Description: Checks if the search is part of the input string in the given position
Author: edKim
Latest version: 0.0.22

# `@plexis/includes`

Checks if the search is part of the input string in the given position

**Installation**
`npm i @plexis/includes`

**Usage**

```javascript
import includes from '@plexis/includes';

includes(); // => false
includes(''); // => false
includes('', ''); // => true
includes('Foo', 'Foo'); // => true
includes('Foo', 'Foo'); // => true
includes('Foo', 'Foo', 2); // => false
includes('Foo', 'oo'); // => true
includes('Foo', 'Oo'); // => false
```

**Aliases**

```javascript
import includes from '@plexis/includes';
import {includes, has} from 'plexis';
```
npm package: @plexis/insert
Description: Inserts into the input text a string at specified position.
Author: Angel Gonzalez
Latest version: 0.0.22

## `@plexis/insert`

Inserts into the input text a string at specified position.

`npm i @plexis/insert`

**Usage**

```javascript
import insert from '@plexis/insert';

insert(); // returns  ''
insert('foo ba'); // returns  'foo ba'
insert('foo ba', 'r'); // returns  'foo bar'
insert('foo ba', 'r', 1); // returns  'foo bar'
insert('foo ba', 'r', 100); // returns  'foo bar'
insert('foo ba', 'r', -100); // returns  'foo bar'
insert('oo bar', 'r', 0); // returns  'foo bar'
```

**Aliases**

```javascript
import insert from '@plexis/insert';
import {insert} from 'plexis';
```
npm package: @plexis/is-alpha
Description: Check whether a string contains only alpha characters.
Latest version: 0.0.22

# `@plexis/isAlpha`

Check whether a string contains only alpha characters.

**Installation**
`npm i @plexis/is-alpha`

**Usage**

```javascript
import isAlpha from '@plexis/is-alpha';

isAlpha('Foo Bar'); // returns false
isAlpha('FooBar'); // returns true
isAlpha('f00b4r'); // returns false
```

**Aliases**

```javascript
import {isAlpha} from 'plexis';
```
npm package: @plexis/is-alphanumeric
Description: Checks whether the input is a string containing only alphanumeric characters.
Latest version: 0.0.22

## `isAlphaNumeric`

Checks whether the input is a string containing only alphanumeric characters.

`npm i @plexis/is-alphanumeric`

**Usage**

```javascript
import isAlphaNumeric from '@plexis/is-alphanumeric';

isAlphaNumeric('foo123BAR'); // returns true
isAlphaNumeric('1.0'); // returns false
isAlphaNumeric('bar!'); // returns false
isAlphaNumeric(''); // returns false
```

**Aliases**

```javascript
import isAlphaNumeric from '@plexis/is-alphanumeric';
import {isAlphaNumeric, isAlphanumeric, isAlphaDigit} from 'plexis';
```
npm package: @plexis/is-lowercase
Description: Checks whether the input is a string containing only lowercase characters
Latest version: 0.0.22

## `isLowerCase`

Checks whether the input is a string containing only lowercase characters

`npm i @plexis/is-lowercase`

**Usage**

```javascript
import isLowerCase from '@plexis/is-lowercase';

isLowerCase('foo'); // returns true
isLowerCase('Foo'); // returns false
isLowerCase('BAR'); // returns false
```

**Aliases**

```javascript
import {isLowerCase} from 'plexis';
import {isLower} from 'plexis';
```
npm package: @plexis/is-numeric
Description: Validates if argument is valid numeric value.
Author: edKim
Latest version: 0.0.22

# `@plexis/isNumeric`

Validates if argument is valid numeric value.

**Installation**
`npm i @plexis/is-numeric`

**Usage**

```javascript
import isNumeric from '@plexis/is-numeric';

isNumeric('1000');
// => true

isNumeric('Infinity');
// => true

isNumeric('-100.4');
// => true

isNumeric('1E+2');
// => true

isNumeric('0xFF');
// => true

isNumeric('-');
// => false

isNumeric('one');
// => false
```

**Aliases**

```javascript
import {isNum} from 'plexis';
import {isNumeric} from 'plexis';
```
npm package: @plexis/is-string
Description: Checks whether the input is a string primitive type.
Latest version: 0.0.22

## `isString`

Checks whether the input is a string primitive type.

`npm i @plexis/is-string`

**Usage**

```javascript
import isString from '@plexis/is-string';

isString('Foo'); // returns 'true'
isString(1); // returns 'false'
isString(null); // returns 'false'
```

**Aliases**

```javascript
import {isString} from 'plexis';
```
npm package: @plexis/is-uppercase
Description: Checks whether the input is a string containing only uppercase characters
Latest version: 0.0.22

## `isUpperCase`

Checks whether the input is a string containing only uppercase characters

`npm i @plexis/is-uppercase`

**Usage**

```javascript
import isUpperCase from '@plexis/is-uppercase';

isUpperCase️('b'); // returns false
isUpperCase️('B'); // returns true
isUpperCase️('BCD'); // returns true
```

**Aliases**

```javascript
import {isUpperCase} from 'plexis';
import {isUpper} from 'plexis';
```
npm package: @plexis/repeat
Description: Repeats the input text number of times.
Latest version: 0.0.22

# `@plexis/repeat`

Repeats the input text number of times.

**Installation**
`npm i @plexis/repeat`

**Usage**

```javascript
import repeat from '@plexis/repeat';

repeat('ABCD');
// => true

repeat('Apollo11', 2);
// => 'Apollo11Apollo11'

repeat('x', 2);
// => 'xx'

repeat('x', 2, '+');
// => 'x+x'

repeat('xx', 2, '_');
// => 'xx_xx'
```

**Aliases**

```javascript
import repeat from '@plexis/repeat';
import {repeat, multiply} from 'plexis';
```
npm package: @plexis/starts-with
Description: Checks whether the input text starts with the given pattern.
Author: Brandon Skinner
Latest version: 0.0.22

## `@plexis/startsWith`

Checks whether the input text starts with the given pattern.

`npm i @plexis/starts-with`

**Usage**

```javascript
import startsWith from '@plexis/starts-with';

startsWith('This is me', 'This is'); // returns true
startsWith('This is me', 'This is', 1); // returns false
startsWith(/[@!#$]/, '@plexis is great!'); // returns true
startsWith(/[A-Z]/, '@plexis is great!'); // returns false
```
npm package: @plexis/tail
Description: Extracts the last length characters from the input text
Latest version: 0.0.22

## `head`

Extracts the last length characters from the input text

`npm i @plexis/tail`

**Usage**

```javascript
import tail from '@plexis/tail';
tail(); // => ''
tail('Hello'); // => 'o'
tail('Hello', 2); // => 'lo'
tail('Hello', 100); // => 'Hello'
```

**Aliases**

```javascript
import {tail} from 'plexis';
import {rest} from 'plexis';
import {last} from 'plexis';
import {pop} from 'plexis';
```
npm package: @plexis/to-camel-case
Description: Converts the input text to camelCase.
Latest version: 0.0.22

# `@plexis/toCamelCase`

Converts the input text to camelCase.

**Installation**
`npm i @plexis/to-camel-case`

**Usage**

```javascript
import toCamelCase from '@plexis/to-camel-case';

toCamelCase('Cool'); //=> 'cool'
toCamelCase('cool mate'); // => 'coolMate'
toCamelCase('Hey how are you today?'); // => 'heyHowAreYouToday'
toCamelCase('PascalCase'); // => 'pascalCase'
toCamelCase('kebab-case'); // => kebabCase
```

**Aliases**

```javascript
import {toCamelCase} from 'plexis';
import {camelCase} from 'plexis';
import {camelize} from 'plexis';
```
npm package: @plexis/to-capitals
Description: Converts the first character of the input text to upper case. If the second parameter is true, the method converts the rest of the subject to lower case
Author: Angel Gonzalez
Latest version: 0.0.22

## `@plexis/to-capitals`

Converts the first character of the input text to upper case. If the second parameter is true, the method converts the rest of the subject to lower case.

`npm i @plexis/to-capitals`

**Usage**

```javascript
import toCapitals from '@plexis/to-capitals';

toCapitals('foo Bar'); // returns 'Foo Bar'
toCapitals('fOO Bar'); // returns 'FOO Bar'
toCapitals('fOO Bar', true); // returns 'Foo bar'
```

**Aliases**

```javascript
import toCapitals from '@plexis/to-capitals';
import {toCapitals, toFirstCapital, capitalize} from 'plexis';
```
npm package: @plexis/to-chicago
Description: Convert text into Chicago style
Latest version: 0.0.22

## `@plexis/to-chicago`

Convert text into Chicago style

`npm i @plexis/to-chicago`

**Usage**

```javascript
import toChicago from '@plexis/to-chicago';

toChicago('This is a title'); // returns 'This Is a Title'
toChicago('in Turabian shows a sample title page for a class paper.'); // returns 'In Turabian Shows a Sample Title Page for a Class Paper.'
toChicago('camelCase PascalCase snake_case and kebab-case'); // returns 'Camelcase Pascalcase Snake_case and Kebab-Case'
```

**Aliases**

```javascript
import toChicago from '@plexis/to-chicago';
import {toTurabian, toChicagoManualStyle, toChicagoStyle, toChicagoTitle} from 'plexis';
```
npm package: @plexis/to-chunks
Description: Splits the input text into an array of chunks.
Author: korczynsk1
Latest version: 0.0.22

# `@plexis/to-chunks`

Splits the input text into an array of chunks.

**Installation**
`npm i @plexis/to-chunks`

**Usage**

```javascript
import toChunks from '@plexis/to-chunks';

toChunks('Hello world');
// => ['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']

toChunks('   ');
// => [' ', ' ', ' ']

toChunks('1234567', 2);
// => ['12', '34', '56', '7']

toChunks('1234567', 6);
// => ['123456', '7']
```

**Aliases**

```javascript
import toChunks from '@plexis/to-chunks';
import {toChunks, chop} from 'plexis';
```
npm package: @plexis/to-human
Description: Converts a string into a human readable text
Author: Angel Gonzalez
Latest version: 0.0.22

# `@plexis/to-human`

Converts a string into a human readable text

## Installation

`npm i @plexis/to-human`

## Usage

```javascript
import toHuman from '@plexis/to-human';

toHuman('foo'); // => 'Foo'
toHuman('foo     bar'); // => 'Foo bar'
toHuman(' foo-bar  baz quxQuux corge_grault GarplyWaldo'); // => 'Foo bar baz qux quux corge grault garply waldo'
toHuman(' foo-bar-baz qux       quux'); // => 'Foo bar baz qux quux'
```

## Aliases

```javascript
import toHuman from '@plexis/to-human';
import {toHuman, humanize} from 'plexis';
```
npm package: @plexis/to-lower
Description: Lowercase the first letter of the given string.
Latest version: 0.0.22

# `@plexis/toLower`

Lowercase the first letter of the given string.

**Installation**
`npm i @plexis/to-lower`

**Usage**

```javascript
import toLower from '@plexis/to-lower';

toLower('Foo Bar', false); // returns 'foo Bar'
toLower('Foo Bar', true); // returns 'foo bar'
toLower('FOO BAR', false); // returns 'fOO BAR'
```

**Aliases**

```javascript
import {toLower} from 'plexis';
import {toFirstLower} from 'plexis';
import {decapitalize} from 'plexis';
```
npm package: @plexis/to-pascal-case
Description: Converts the input text to pascal case
Latest version: 0.0.22

## `toPascalCase`

Converts the input text to pascal case

`npm i @plexis/name-of-the-module`

**Usage**

```javascript
import toPascalCase from '@plexis/to-pascal-case';

toPascalCase('Cool');
// => 'Cool'

toPascalCase('cool mate');
// => 'CoolMate'

toPascalCase('Hey how are you today?');
// => 'HeyHowAreYouToday'

toPascalCase('camelCase');
// => 'CamelCase'

toPascalCase('kebab-case');
// => KebabCase
```

**Aliases**

```javascript
import toPascalCase from '@plexis/to-pascal-case';
import {toPascalCase, classify} from 'plexis';
```
npm package: @plexis/to-plural
Description: Converts a word to its plural form
Author: shilangyu
Latest version: 0.0.22

# `@plexis/to-plural`

Converts a word to its plural form

## Installation

`npm i @plexis/to-plural`

## Usage

```javascript
import toPlural from '@plexis/to-plural';

toPlural('example'); // => 'examples'
toPlural('example', 10); // => 'examples'
toPlural('example', 1); // => 'example'
toPlural('example', 'examplez', 10); // => 'examplez'
toPlural('example', 'examplez', 1); // => 'example'
```

## Aliases

```javascript
import toPlural from '@plexis/to-plural';
import {toPlural, pluralize} from 'plexis';
```
npm package: @plexis/to-pred
Description: Converts a string to its equivalent predecessor.
Latest version: 0.0.22

## `@plexis/toPred`

Converts a string to its equivalent predecessor.

**Installation**
`npm i @plexis/to-pred`

**Usage**

```javascript
import toPred from '@plexis/to-pred';

toPred('b'); // returns 'a'
toPred('B'); // returns 'A'
toPred('BCD'); // returns 'ABC'
```

**Aliases**

```javascript
import {toPred} from 'plexis';
import {toPredecessor} from 'plexis';
```
npm package: @plexis/to-snake-case
Description: Converts the input text to camelCase.
Latest version: 0.0.22

# `@plexis/toSnakeCase`

Converts the input text to camelCase.

**Installation**
`npm i @plexis/to-snake-case`

**Usage**

```javascript
import toSnakeCase from '@plexis/to-snake-case';

toSnakeCase('Cool'); // => 'cool'
toSnakeCase('cool mate'); // => 'cool_mate'
toSnakeCase('Hey how are you today?'); // => 'hey_how_are_you_today'
toSnakeCase('PascalCase'); // => 'pascal_case'
toSnakeCase('kebab-case'); // => kebab_case
```

**Aliases**

```javascript
import {toSnakeCase} from 'plexis';
import {snakeCase} from 'plexis';
```
npm package: @plexis/to-succ
Description: Converts a string to its equivalent successor.
Latest version: 0.0.22

## `@plexis/toSucc`

Converts a string to its equivalent successor.

**Installation**
`npm i @plexis/to-succ`

**Usage**

```javascript
import toSucc from '@plexis/to-succ';

toSucc('a'); // returns 'b'
toSucc('A'); // returns 'B'
toSucc('ABCD'); // returns 'BCDE'
```

**Aliases**

```javascript
import {toSucc} from 'plexis';
import {toSuccessor} from 'plexis';
```
npm package: @plexis/to-swap
Description: Swaps every character with the next one in a given string.
Latest version: 0.0.22

## `@plexis/toSwap`

Swaps every character with the next one in a given string.

`npm i @plexis/to-swap`

**Usage**

```javascript
import toSwap from '@plexis/to-swap';

toSwap('ab'); // returns 'ba'
toSwap('abc'); // returns 'bac'
toSwap('abcd'); // returns 'badc'
toSwap('a b'); // returns ' ab'
```

**Aliases**

```javascript
import {toSwap} from 'plexis';
import {swap} from 'plexis';
```
npm package: @plexis/to-swap-case
Description: Swaps lowercase to uppercase and vice versa for the input text.
Latest version: 0.0.22

# `@plexis/to-swap-case`

Swaps lowercase to uppercase and vice versa for the input text.

**Installation**
`npm i @plexis/to-swap-case`

**Usage**

```javascript
import toSwapCase from '@plexis/to-swap-case';

toSwapCase('Hello WORLD'); // => 'hELLO world'
toSwapCase('123 toys'); // => '123 TOYS'
```

**Aliases**

```javascript
import toSwapCase from '@plexis/to-swap-case';
import {toSwapCase, swapCase} from 'plexis';
```
npm package: @plexis/to-title
Description: Converts a string to a title, capitalizes the first letter of each word.
Latest version: 0.0.22

## `@plexis/toTitle`

Converts a string to a title, capitalizes the first letter of each word.

**Installation**
`npm i @plexis/to-title`

**Usage**

```javascript
import toTitle from '@plexis/to-title';

toTitle('this is cool mate'); // returns 'This Is Cool Mate'
```

**Aliases**

```javascript
import {toTitle} from 'plexis';
import {titleize} from 'plexis';
```
npm package: @plexis/when
Description: `when` is used for checking and chaining within the composition for supercharged functions.
Latest version: 0.0.22

## `when`

`when` is used for checking and chaining within the composition for supercharged functions.

`npm i @plexis/when`

**Usage**

```javascript
import compose from '@plexis/compose';
import when from '@plexis/when';

const inc = x => x + 1;
const add = (x, y) => x + y;
const setToZero = () => 0;

const compose = (...fns) => x => fns.reduce((r, f) => f(r), x);
const when = (cond, f) => x => (cond(x) ? f(x) : x);

const ops = compose(
  inc,
  x => add(x, 2),
  when(num => num > 0, compose(setToZero))
);

ops(1); // returns 0
ops(100); // returns 0
ops(-100); // returns -97
```

**Aliases**

```javascript
import when from '@plexis/when';
import {when} from 'plexis';
```
npm package: @plexis/without-diacritics
Description: Cleanups a string from diacritics.
Latest version: 0.0.22

## `@plexis/withoutDiacritics`

Cleanups a string from diacritics.

**Installation**
`npm i @plexis/without-diacritics`

**Usage**

```javascript
import withoutDiacritics from '@plexis/without-diacritics';

withoutDiacritics('áéíóú'); // returns 'aeiou'
```

**Aliases**

```javascript
import {withoutDiacritics} from 'plexis';
import {cleanDiacritics} from 'plexis';
import {removeDiacritics} from 'plexis';
```
npm package: @plexis/without-html
Description: Removes HTML tags from the input text.
Latest version: 0.0.22

# `@plexis/withoutHTML`

Removes HTML tags from the input text.

**Installation**
`npm i @plexis/without-html`

**Usage**

```javascript
import withoutHTML from '@plexis/without-html';

withoutHTML('Hello world'); // => 'Hello world'
withoutHTML('<p>Hello</p> world'); // => ' world'
withoutHTML('<p Hello world'); // => '<p Hello world'
withoutHTML('<p id="">Hello world</p>'); // => ''
withoutHTML('<p id="" Hello world</p> <b></b> from the underground'); // => ' from the underground'
```

**Aliases**

```javascript
import withoutHTML from '@plexis/without-html';
import {withoutHTML, removeHTML} from 'plexis';
```
npm package: @plexis/without-indent
Description: Removes leading whitespaces from each line in a string
Latest version: 0.0.22

## `withoutIndent`

Removes leading whitespaces from each line in a string

`npm i @plexis/without-indent`

**Usage**

```javascript
import withoutIndent from '@plexis/without-indent';

withoutIndent('\t\t\tHello World'); // returns 'Hello World'
withoutIndent('\n\tHello\n\tWorld'); // returns '\nHello\nWorld'
```

**Aliases**

```javascript
import {removeIndent} from 'plexis';
import {dedent} from 'plexis';
```
npm package: @plexmint/mcp-server
Description: PlexMint MCP Server — Connect AI agents to the PlexMint prompt marketplace
Author: PlexMint
Latest version: 0.1.4

# @plexmint/mcp-server

Connect AI agents to the [PlexMint](https://plexmint.com) prompt marketplace via Model Context Protocol (MCP).

## Quick Setup

### Claude Code
```bash
claude mcp add plexmint -- npx @plexmint/mcp-server
```

### With API key (for purchases, selling, reviews)
```bash
claude mcp add plexmint -e PLEXMINT_API_KEY=pm_your_key_here -- npx @plexmint/mcp-server
```

### Manual config (~/.claude.json)
```json
{
  "mcpServers": {
    "plexmint": {
      "command": "npx",
      "args": ["@plexmint/mcp-server"],
      "env": {
        "PLEXMINT_API_KEY": "pm_your_key_here"
      }
    }
  }
}
```

## Tools

| Tool | Auth Required | Description |
|------|:---:|-------------|
| `plexmint_prompts` | No | Browse, search, filter, and view prompt details |
| `plexmint_purchase` | Yes | Buy a prompt with wallet credits or Stripe |
| `plexmint_wallet` | Yes | Check balance, view library, get purchased prompt content |
| `plexmint_register` | No | Create account and verify email |
| `plexmint_review` | Yes | Rate and review purchased prompts |
| `plexmint_sell` | Yes | List new prompts or update existing ones |

## Getting Started

1. **Browse prompts** (no account needed):
   > "Search PlexMint for code review prompts"

2. **Create an account**:
   > "Register me on PlexMint as an agent"

3. **Verify and get API key**:
   > "Verify my PlexMint email with code 123456"

4. **Add API key to config**, then restart Claude Code

5. **Buy and use prompts**:
   > "Purchase the NUE-SEO01 prompt from PlexMint"
   > "Show me the content of the prompt I just bought"

## Environment Variables

| Variable | Required | Description |
|----------|:---:|-------------|
| `PLEXMINT_API_KEY` | For auth tools | Your PlexMint API key |
| `PLEXMINT_BASE_URL` | No | Override API URL (default: https://plexmint.com/api/v1) |

## License

MIT
npm package: @plexswap/eslint-config
Description: Eslint config for PlexSwap
Author: RabbitDoge
Latest version: 3.1.5

# eslint-config

Plexswap Eslint config with:

- Airbnb config
- Typescript
- Prettier

## Usage

```
npx install-peerdeps --dev @plexswap/eslint-config
```

Add `"extends": "@plexswap/eslint-config"` to your eslint config file.
npm package: @plexswap/extended-lm-pool
Description: Liquidity Mining Pool (LM Pool) is a separate contract for liquidity mining reward accounting. It is not meant to be deployed manually. It will be deployed automatically by ChiefFarmerExtended with LmPoolDeployer whenever there is a new liquidity mining c
Latest version: 1.0.3

# extended-lm-pool

Liquidity Mining Pool (LM Pool) is a separate contract for liquidity mining
reward accounting.
It is not meant to be deployed manually.
It will be deployed automatically by ChiefFarmerExtended with LmPoolDeployer whenever
there is a new liquidity mining campaign.
As for testing, please check the tests in ChiefFarmerExtended which is the main testing
entry point to test the correctness of the reward calculation.