open-index/open-npm huggingface dataset:
npm package: @solarwinter/captchajs
Description: Sample implementation for captchas.net
Author: Paul Walker
Latest version: 0.2.1

# captchajs

[![CircleCI](https://circleci.com/gh/arafel/CaptchaJs.svg?style=svg)](https://circleci.com/gh/arafel/CaptchaJs)

CaptchaJs is a JavaScript library with the aim of making it easy to
use the [captchas.net](http://captchas.net) service.

### Installation

```
yarn add @solarwinter/captchajs
```

or

```
npm install @solarwinter/captchajs
```

### Usage

For testing and development you can use the example values seen on the bottom of the
[captchas.net webpage](http://captchas.net/registration/):

* username `demo`
* secret key `secret`
* random string `RandomZufall`

Load the username and secret key into your program - the common method is via .env file - and use
them to initialise CaptchaJs.

```typescript
import { CaptchaJs } from "@solarwinter/captchajs";

const captcha = new CaptchaJs({ client: process.env.CAPTCHAS_CLIENT,
                                secret: process.env.CAPTCHAS_SECRET });
const random = captcha.getRandomString();
const imageUrl = captcha.getImageUrl({ randomString: random })
const audioUrl = captcha.getAudioUrl({ randomString: random })
```

Those URLs need to be passed to the page shown to the user. The exact method of doing so will vary; if you're using
ERB (similar to Jinja or Mustache) then it might look like this:

```html

<div>
    <img src="<%= captchaImageUrl %>" alt="Captcha image">
    <a href="<%= captchaAudioUrl %>" alt="Audio version of captcha">Captcha audio</a>
    <label for="captchaPassword">
        Captcha text?
    </label>
    <input type="hidden" name="randomString" value="<%= randomString %>"/>
    <input name="captchaPassword" type="text" required/>
</div>
```

When the user hits Submit on the form, the fields should be POSTed back to your server application. There you can check
the captcha string - for example:

```typescript
if (!captcha.validateRandomString(data.randomString)) {
  console.log(`Error validating random string ${data.randomString}`);

  // At this point you can re-render the contact page, for example with error text:
  //   "That captcha has expired or already been used"
} else if (!captcha.verifyPassword(data.randomString, data.captchaPassword)) {
  console.log(`Error verifying password ${data.captchaPassword}`);

  // At this point you can re-render the contact page, for example with error text:
  //   "Sorry, you got the captcha text wrong. Please try again."
} else {
  console.log("Captcha passed!");
  // Do something here!
}
```

Before you can use this package in production you need to [register with the
captchas.net](http://captchas.net/registration/) service. When you've registered you should receive an email from
captchas.net
containing your client ID (or 'user name') and the shared secret.
npm package: @solarwinter/knex-cleaner
Description: Database cleaner for Knex.js and bookshelf.js
Author: Paul Walker
Latest version: 1.4.3

# knex-cleaner

[![CircleCI](https://circleci.com/gh/arafel/knex-cleaner.svg?style=svg)](https://circleci.com/gh/arafel/knex-cleaner)

Helper library to clean a PostgreSQL, MySQL or SQLite3 database tables
using Knex. Great for integration tests.

### Installation
```
npm install --save-dev @solarwinter/knex-cleaner
```

or

```
yarn add -D @solarwinter/knex-cleaner
```

### Usage
```javascript
var knexCleaner = require('knex-cleaner');

var knex = require('knex')({
  client: 'mysql',
  connection: {
    host     : '127.0.0.1',
    user     : 'your_database_user',
    password : 'your_database_password',
    database : 'myapp_test'
  }
});

knexCleaner.clean(knex).then(function() {
  // your database is now clean
});

// You can also use this in BookshelfJS
var bookshelf = require('bookshelf')(knex);

knexCleaner.clean(bookshelf.knex).then(function() {

});

// You can also pass if it deletes the tables with delete instead of truncate
// as well as a list of tables to ignore.

var options = {
  mode: 'delete', // Valid options 'truncate', 'delete'
  restartIdentity: true, // Used to tell PostgresSQL to reset the ID counter
  ignoreTables: ['Dont_Del_1', 'Dont_Del_2']
}

knexCleaner.clean(knex, options).then(function() {
  // your database is now clean
});
```
The example above used MySQL but it has been tested on PostgreSQL and SQLite3.

# Continued work

This package is based on the original [knex-cleaner package by Steven
Ferguson](https://github.com/steven-ferguson/knex-cleaner). At the
time of writing that package has not been updated for 3 years, and has
out of date dependencies with known security holes. Since that package
appears dormant I've published my fork with updated deps in the hope
it will be useful for someone.
npm package: @solashi/go-mysql-binlog-node
Description: A Node.js MySQL binlog listener based on go-mysql
Author: Pham Van Cong
Latest version: 0.0.6

# @solashi/go-mysql-binlog-node

A library wrapping the [go-mysql](https://github.com/go-mysql-org/go-mysql) package, providing a MySQL client connector and binlog parsing implementation.

> This project is forked from [go-mysql-js](https://github.com/mcuelenaere/mysql-binlog-node)

## Installation

```bash
npm i --save @solashi/go-mysql-binlog-node
```

* Enable MySQL binlog in `my.cnf`, restart MySQL server after making the changes.
  > binlog checksum is enabled by default. @solashi/go-mysql-binlog-node can work with it, but it doesn't really verify it.

  ```
  # Must be unique integer from 1-2^32
  server-id        = 1
  # Row format required
  binlog_format    = row
  # Directory must exist. This path works for Linux. Other OS may require
  #   different path.
  log_bin          = /var/log/mysql/mysql-bin.log

  binlog_do_db     = employees   # Optional, limit which databases to log
  expire_logs_days = 10          # Optional, purge old logs
  max_binlog_size  = 100M        # Optional, limit log size
  ```

* Create an account with replication privileges, e.g. given privileges to account `root` (or any account that you use to read binary logs)

  ```sql
  GRANT REPLICATION SLAVE, REPLICATION CLIENT, SELECT ON *.* TO 'root'@'localhost'
  ```

## Example

```js
import MysqlBinlog from '@solashi/go-mysql-binlog-node';

async function main() {
    let syncer = await MysqlBinlog.create({
        hostname: "localhost",
        port: 3306,
        username: "root",
        password: "mypassword",
        tableRegexes: ['Users'],
    });
    syncer.on('event', (event) => {
        console.log('got row event', event);
    });
    syncer.on('error', (err) => {
        console.error('got error', err);
    });

    process.on('SIGINT', function() {
        console.log("Caught interrupt signal");
        syncer.close();
    });
}

main().catch(err => {
    console.error(err);
    process.exit(1);
});
```
npm package: @solcial.io/jup-ag-core
Description: ![1*cXNgzu0Pvj4HwOLw4Akwqg](https://user-images.githubusercontent.com/34560707/145749257-e48cb199-521b-476e-9d81-f79bb45ef834.png)
Author: zhengyutay
Latest version: 3.0.2

# Jupiter Aggregator Core typescript library

![1*cXNgzu0Pvj4HwOLw4Akwqg](https://user-images.githubusercontent.com/34560707/145749257-e48cb199-521b-476e-9d81-f79bb45ef834.png)

<p align="center">
  <a href="https://jup.ag">Jupiter Aggregator (jup.ag)</a>
  <br/>
  The best swap aggregator on Solana.  Built for smart traders who like money.
</p>
<br/>

This repo is Jupiter Core SDK.


## Example
For Node, or build your own lib, use [Jupiter Core Example](https://github.com/mercurial-finance/jupiter-core-example)
## Integrate with React instead?
The quickest way to integrate Jupiter with your UI, use [Jupiter React Hook instead](https://www.npmjs.com/package/@jup-ag/react-hook)
## React Native?
Checkout [Jupiter React Native Example](https://github.com/mercurial-finance/jupiter-react-native)


# Installation

Yarn
```
yarn add @jup-ag/core
```

NPM
```
npm install @jup-ag/core
```

<br/>
<hr/>
<br/>

### Jupiter.load()
```
Initialize and load Jupiter instances
```

### jupiter.getRouteMap()
```
Get routeMap, which maps each tokenMint and their respective tokenMints that are swappable
```

### jupiter.computeRoutes()
```
Request Jupiter to compute the requested inputToken and outputToken, to query possible pairs, routes, amounts, slippage and more information.
```
npm package: @solcial.io/slcl-light-swap-vue-demo
Description: This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
Latest version: 1.0.0

# Vue 3 + TypeScript + Vite

This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.

## Recommended IDE Setup

- [VS Code](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar)

## Type Support For `.vue` Imports in TS

Since TypeScript cannot handle type information for `.vue` imports, they are shimmed to be a generic Vue component type by default. In most cases this is fine if you don't really care about component prop types outside of templates. However, if you wish to get actual prop types in `.vue` imports (for example to get props validation when using manual `h(...)` calls), you can enable Volar's Take Over mode by following these steps:

1. Run `Extensions: Show Built-in Extensions` from VS Code's command palette, look for `TypeScript and JavaScript Language Features`, then right click and select `Disable (Workspace)`. By default, Take Over mode will enable itself if the default TypeScript extension is disabled.
2. Reload the VS Code window by running `Developer: Reload Window` from the command palette.

You can learn more about Take Over mode [here](https://github.com/johnsoncodehk/volar/discussions/471).