open-index/open-npm huggingface dataset:
npm package: @hotg-ai/rune-wit-files
Description: JavaScript glue for loading a WebAssembly module that follows the interface defined in the [`@hotg-ai/wit-files`][repo] repo's various `rune/*.wit` files.
Latest version: 0.3.2

# Rune WIT Files

JavaScript glue for loading a WebAssembly module that follows the interface
defined in the [`@hotg-ai/wit-files`][repo] repo's various `rune/*.wit` files.

[repo]: https://github.com/hotg-ai/wit-files
npm package: @hotgarbage/ioreg
Description: Query I/O Kit registry
Author: rogerbf
Latest version: 0.0.2

# ioreg

``` bash
npm install --save ioreg
```

## Usage

``` javascript
const ioreg = require('ioreg')

ioreg('AppleSmartBattery')
  .then(result => console.log(result))
  .catch(err => console.error(err))

// [
//   {
//     AdapterInfo: 0,
//     Amperage: 4683,
//     AvgTimeToEmpty: 65535,
//     AvgTimeToFull: 130,
//     BatteryInstalled: true,
//     BatteryInvalidWakeSeconds: 30,
//     ...
//   }
// ]
```

### Options

Options can be passed to ```ioreg```, e.g.

``` javascript
ioreg('gpu-sensor', ['-i'])
```
npm package: @hotgarbage/sort-json
Description: sort-json =========
Author: David Björklund
Latest version: 2.1.0

sort-json
=========

It takes a JSON file and returns a copy of the same file, but with the sorted keys.

installation
------------

` [sudo] npm -g install sort-json`


usage
-----

```js
const sortJson = require('sort-json');

const options1 = { ignoreCase: true, reverse: true };
const copy = sortJson({ AA: 123, a: 1, b: 21 }, options1);
// copy => { b: 21, AA: 123, a: 1 }

sortJson.overwrite('some/absolute/path.json');
// sorts the json at absolute path and overwrites file, also returns sorted object

sortJson.overwrite(['some/absolute/path1.json', 'some/absolute/path2.json']);
// sorts the json at absolute paths and overwrites files, also returns array of sorted objects
```

CLI usage
---------
`sort-json file.json` => sorts and overwrites file.json

`-i` or `--ignore-case` to ignore case when sorting.

`-r` or `--reverse` to reverse order z -> a

tests
-----

`npm test`
npm package: @hotglue/cron-builder
Description: simple API for building cron expressions
Author: Tyler Waneka
Latest version: 0.3.1

[![Build Status](https://travis-ci.org/srcclr/cron-builder.svg)](https://travis-ci.org/srcclr/cron-builder)
# cron-builder
The software utility *cron* is a time-based scheduler in Unix-like computer operating systems. A user may use cron to schedule jobs (commands or scripts) to run periodically at fixed times, dates, or intervals. A cron statement is composed of 5 fields separated by white space. The `*` character translates to "every", ie: "every minute" or "every day of the week". 

cron-builder will manage the state of a cron expression, allowing a user to manipulate it through a simple API. It is decoupled from the DOM and doesn't have an opinion about where it's being called from. cron-builder considers [this article](https://en.wikipedia.org/wiki/Cron) its source of truth. 

### Install
cron-builder is available on npm and bower:
```
npm install cron-builder --save
```
or
```
bower install cron-builder --save
```

After installing, just require the package as you normally would:
```
var cb = require('/path/to/cron-builder.js');
```



### API
To instantiate the cron builder:

```JavaScript
// (default expression is set to "* * * * *")
var cronExp = new cb();

// optionally, pass in a cron expression to override the default:
var myCronExp = new cb('5 12 * * 1-5')
```

To return the cron expression at any given time:
```JavaScript
cronExp.build();
// '* * * * *'
```

API includes basic getters and setters:
```JavaScript
cronExp.get('minute');
// '*'
cronExp.set('minute', '5,35');
// '5,35'
cronExp.get('minute');
// '5,35'
cronExp.build();
// '5,35 * * * *'
```

Or if you'd prefer to add or remove values one at a time, use `addValue` and `removeValue`. These methods build or take away from what is currently set:
```JavaScript
cronExp.addValue('hour', '2');
cronExp.addValue('monthOfTheYear', '4');
cronExp.addValue('monthOfTheYear', '10');
cronExp.build();
// '5,35 2 * 4,10 *'

cronExp.removeValue('minute', '5');
cronExp.build();
// '35 2 * 4,10 *'
```

If you prefer to work with the expression object directly, use `getAll` and `setAll`:
```JavaScript
var exp = cronExp.getAll();
// {minute: ['35'], hour: ['2'], dayOfTheMonth: ['*'], monthOfTheYear: ['4','10'], ...}
exp.dayOfTheMonth = ['7','14','21','28'];
cronExp.setAll(exp);
cronExp.build();
// '35 2 7,14,21,28 4,10 *'
```

##### Notes:
- cron-builder does not currently support using `/` syntax to indicate values that are repeated. Instead of using `*/15`, use the verbose form `0,15,30,45`.
- cron-builder requires using numeric representations of days of the week and months of the year. So instead of using `Feb,Mar,Apr` just use `2,3,4`.

### Contribute
Easy!
```
npm install
npm test
```
Pull requests and issues appreciated!

### TODO
- more validation for things like adding values that are already included in a range, better range validations...
- sorting of values for a given measure of time

### License

The MIT License (MIT)
npm package: @hoth/molecule
Description: molecule plugin for hoth framework
Author: yuanxueran
Latest version: 1.1.5

# @hoth/molecule

### Demo

controller.ts

```
import {FastifyLoggerInstance} from 'fastify';
import {Controller as IController} from '@baidu/molecule';

export class Controller implements IController {
    root: string;
    logger: FastifyLoggerInstance;

    constructor(options: Option) {
        this.logger = options.logger;
        this.root = options.root;
    }

    render(data: Data) {
        return `appname is ${data.appname}, route name is ${data.name}, title is ${data.title}`;
    }
}
```

node server

```
import {molecule} from '@hoth/molecule';

let ret = await molecule(ctrlPath, data, {
    root: '/dist',
    appName: 'appname',
    name: 'route name',
    logger: fastify.log,
});
```
npm package: @hoth/schema
Description: 提供将 interface 转换为 json schema 并在 hoth 中使用的能力。
Latest version: 2.0.1

# @hoth/schema

提供将 interface 转换为 json schema 并在 hoth 中使用的能力。

## 使用方式

### 编译

提供了一个 gulp 插件，用于编译所有 interfaces。

```javascript
import {compileInterface} from '@hoth/schema';

function compile() {
    return src('src/interfaces/**/*.ts')
        .pipe(compileInterface({
            fileName: 'schema.json'
        }))
        .pipe(dest('dist/interfaces'));
}
```

所有 interface 会编译为一个文件，在运行时需要加载这个文件。

### 运行时初始化

使用 initSchema 函数来初始化生成的 schema。

```ts
import path from 'path';
import {FastifyInstance} from 'fastify';
import {initSchema} from '@hoth/schema';
export default async function main(fastify: FastifyInstance, config) {
    await initSchema(fastify, {
        schemaPath: path.resolve(__dirname, './interfaces/schema.json')
    });
    return fastify;
}
```

### 在 controller 中使用

所有的 interface 都会转为 json schema，并通过 fastify 的 addSchema 函数添加到当前应用。通过 ref 语法使用即可：

```ts
import {Controller, GET, Inject} from '@hoth/decorators';
import {FastifyReply, FastifyRequest} from 'fastify';

@Controller('/index')
export default class AppController {

    @GET({
        url: '',
        options: {
            schema: {
                querystring: {$ref: 'hoth/aaa.ts#/definitions/bbb'}
            }
        }
    })
    getApp(req: FastifyRequest, reply: FastifyReply) {

        return '';
    }
}
```

### 自定义 schema id

默认生成的 id 为 `hoth/${文件名}`，不同目录下的同名文件可能会冲突。

可以在编译时通过以下方式自定义 schema id：

```js
import {compileInterfaceToSchema} from '@hoth/schema/dist/gulp';

function compile() {
    return src('src/interfaces/**/*.ts')
        .pipe(compileInterfaceToSchema({
            fileName: 'schema.json',
            getId(filePath) {
                return ''; // 这里根据 filePath 生成一个新的 id 来返回。
            }
        }))
        .pipe(dest('dist/interfaces'));
}
```
npm package: @hoth/thread
Description: thread pool plugin for hoth framework
Author: meixg
Latest version: 1.0.5

# @hoth/thread

thread worker pool based on piscina.

## 使用方式

### main

- fastify 插件

    该插件会在 fastify 实例上新增两个属性，内部使用 fastify-plugin 来包裹，因此会在全局实例上增加：

    * `fastify.piscina` {`Piscina`} Piscina 实例
    * `fastify.runTask()` {`Function`} Piscina runTask 函数

    ```ts
    import {threadPlugin} from '@hoth/thread';
    import fastify from 'fastify';
    import path from 'path';

    const app = fastify();

    app.register(threadPlugin, {
        threadsNumber: 10,
        filename: path.resolve(__dirname, 'worker.js')
    })

    app.get('/', async (request, reply) => {
    reply.send({ hello: `world [${await app.runTask({ a: 1, b: 2 })}]` });
    });
    ```

- initThread

    如果不想在全局实例上增加属性，可以单独调用 initThread 方法：

    ```ts
    import {initThread} from '@hoth/thread';
    const pool = await initThread({
        threadsNumber: 10,
        filename: path.resolve(__dirname, 'worker.js')
    });

    // 自己处理 pool 的使用方式
    fastify.decorate('piscina', pool);
    fastify.decorate('runTask', (...args) => pool.runTask(...args));
    ```


### worker

```ts
import {
    workerWrapper,
    workerData
} from '@hoth/thread';

export default workerWrapper(function (args) {
    // use workerData
    // some task
});
```

## 异常处理

### 初始化时

当子线程创建失败，会有异常抛出，需要业务方自行处理。

```ts
try {
    await app.register(thread, {
        threadsNumber: 10
    });
}
catch (e) {
    // do something
}
```

或

```ts
app.register(thread, {
    threadsNumber: 10
});
try {
    await app.listen(3000);
}
catch (e) {
    // do something
}
```

initThread 时

```ts
try {
    const pool = await initThread({
        threadsNumber: 10,
        filename: path.resolve(__dirname, 'worker.js')
    });
}
catch (e) {
    // do something
}
```

### runTask 时

```ts
try {
    await fastifyInstance.runTask();
}
catch (e) {
    // do something
}
```
npm package: @hoth/typescript-to-json-schema
Description: typescript to json-schema transpiler
Author: cxtom
Latest version: 2.1.2

# typescript-to-json-schema

![Language](https://img.shields.io/badge/-TypeScript-blue.svg)
[![npm package](https://img.shields.io/npm/v/@hoth%2ftypescript-to-json-schema.svg)](https://www.npmjs.org/package/@hoth/typescript-to-json-schema)
[![Build Status](https://travis-ci.org/max-team/typescript-to-json-schema.svg?branch=master)](https://travis-ci.org/max-team/typescript-to-json-schema)

TypeScript to JsonSchema Transpiler

## Usage

### Programmatic use

```typescript
import {resolve} from 'path';
import {generateSchema} from '@hoth/typescript-to-json-schema';

const {schemas} = generateSchema([resolve('demo.ts')]);
```

### Annotations

For example

`company.ts`：

```typescript
import { integer } from "@hoth/typescript-to-json-schema";

type employee = {

    /**
     * 雇员名字
     *
     * @maxLength 50
     * @minLength 1
     */
    name: string;

    /**
     * 雇员年龄
     *
     * @minimum 18
     */
    age: integer;
};

interface Department {

    /**
     * 是否开始
     */
    open: boolean | null;

    /**
     * 员工
     *
     * @maxItems 1000
     */
    employee: employee[]
}

export interface Company {

    /**
     * 部门
     *
     * @minItems 1
     */
    departments: Department[]
}
```

output

```json
    {
      "$schema": "http://json-schema.org/draft-07/schema#",
      "$id": "http://www.baidu.com/schemas/company.json",
      "$ref": "#/definitions/company",
      "definitions": {
        "department": {
          "type": "object",
          "properties": {
            "open": {
              "oneOf": [
                {
                  "type": "boolean"
                },
                {
                  "type": "null"
                }
              ],
              "description": "是否开始"
            },
            "employee": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/employee"
              },
              "maxItems": 1000,
              "description": "员工"
            }
          },
          "required": [
            "open",
            "employee"
          ]
        },
        "company": {
          "type": "object",
          "properties": {
            "departments": {
              "type": "array",
              "items": {
                "$ref": "#/definitions/department"
              },
              "minItems": 1,
              "description": "部门"
            }
          },
          "required": [
            "departments"
          ]
        },
        "employee": {
          "type": "object",
          "properties": {
            "name": {
              "type": "string",
              "minLength": 1,
              "maxLength": 50,
              "description": "雇员名字"
            },
            "age": {
              "type": "integer",
              "minimum": 18,
              "description": "雇员年龄"
            }
          },
          "required": [
            "name",
            "age"
          ]
        }
      }
    }
```
npm package: @hoth/view
Description: template engine for hoth framework
Author: cxtom
Latest version: 2.0.2

# @hoth/view

## Usage

1. register view plugin in app.ts

```ts
import path from 'path';
import view from '@hoth/view';
import ejs from 'ejs';
import type {FastifyInstance} from 'fastify';
import type {AppConfig} from '@hoth/app-autoload';

export default async function main(fastify: FastifyInstance, config: AppConfig) {
    await fastify.register(view, {
        engine: {
            ejs,
        },
        renderOnly: true,
        templatesDir: path.join(config.dir, 'view'),
    });
    return fastify;
}
```

2. use reply.render to render view

```ts
const html = await reply.render('index.tpl', {
    name: 'world',
});

reply.send(html);
```
npm package: @hoth/vue-style-loader
Description: Vue.js style loader module for webpack
Author: Evan You
Latest version: 4.3.1

# vue-style-loader [![Build Status](https://circleci.com/gh/vuejs/vue-style-loader/tree/master.svg?style=shield)](https://circleci.com/gh/vuejs/vue-loader/tree/master) [![npm package](https://img.shields.io/npm/v/vue-style-loader.svg)](https://www.npmjs.com/package/vue-style-loader)

This is a fork based on [style-loader](https://github.com/webpack/style-loader). Similar to `style-loader`, you can chain it after `css-loader` to dynamically inject CSS into the document as style tags. However, since this is included as a dependency and used by default in `vue-loader`, in most cases you don't need to configure this loader yourself.

## Options

- **manualInject** (3.1.0+):

  Type: `boolean`. When importing the style from a non-vue-file, by default the style is injected as a side effect of the import. When `manualInject` is true, the imported style object exposes a `__inject__` method, which can then be called manually at appropriate timing. If called on the server, the method expects one argument which is the `ssrContext` to attach styles to.

  ``` js
  import styles from 'styles.scss'

  export default {
    beforeCreate() { // or create a mixin for this purpose
      if(styles.__inject__) {
        styles.__inject__(this.$ssrContext)
      }
    }

    render() {
      return <div class={styles.heading}>Hello World</div>
    }
  }
  ```

  Note this behavior is enabled automatically when `vue-style-loader` is used on styles imported within a `*.vue` file. The option is only exposed for advanced usage.

- **ssrId** (3.1.0+):

  Type: `boolean`. Add `data-vue-ssr-id` attribute to injected `<style>` tags even when not in Node.js. This can be used with pre-rendering (instead of SSR) to avoid duplicate style injection on hydration.

- **insert** (4.3.1+):

  Type: `string`. query selector string, used by `document.querySelector()` to pick style insert location.

## Differences from `style-loader`

### Server-Side Rendering Support

When bundling with `target: 'node'`, the styles in all rendered components are collected and exposed on the Vue render context object as `context.styles`, which you can simply inline into your markup's `<head>`. If you are building a Vue SSR app, you probably should use this loader for CSS imported from JavaScript files too.

### Misc

- Does not support url mode and reference counting mode. Also removed `singleton` and `insertAt` query options. It always automatically pick the style insertion mechanism that makes most sense. If you need these capabilities you should probably use the original `style-loader` instead.

- Fixed the issue that root-relative URLs are interpreted against chrome:// urls and make source map URLs work for injected `<style>` tags in Chrome.

## License

MIT
npm package: @hotheadhacker/hello-world
Description: A tiny package that says hello
Author: hotheadhacker
Latest version: 1.0.3

# Hello World

<!-- GitAds-Verify: X9SPVKNYDQ93VRDVPFXTU57AQ3X8S4JG -->

## GitAds Sponsored
[![Sponsored by GitAds](https://gitads.dev/v1/ad-serve?source=@hotheadhacker/hello-world@npm)](https://gitads.dev/v1/ad-track?source=@hotheadhacker/hello-world@npm)

Test Package
npm package: @hotjar/browser
Description: Bring Hotjar directly to your application
Latest version: 1.0.9

# @hotjar/browser

[![@hotjar/browser](https://img.shields.io/npm/v/@hotjar/browser.svg?label=@hotjar/browser)](https://www.npmjs.com/package/@hotjar/browser)

> Bring [Hotjar](https://www.hotjar.com/) directly to your application

## Installation

Add this package as a dependency in your project, then import the library in your code.

```bash
yarn add @hotjar/browser
```

```javascript
import Hotjar from '@hotjar/browser';
```

## Initialize Hotjar

In order for Hotjar to run, it needs to be initialized with your site ID.
You can find your site ID on [this page](https://insights.hotjar.com/site/list) just before your site name.

```javascript
const siteId = 123;
const hotjarVersion = 6;

Hotjar.init(siteId, hotjarVersion);

// Initializing with `debug` option:
Hotjar.init(siteId, hotjarVersion, {
  debug: true
});
```

## Identify API

One of the main interest of this library is to be able to use [Hotjar Identify API](https://help.hotjar.com/hc/en-us/articles/360033640653-Identify-API-Reference).

```javascript
const userId = 'abc_123';
const firstName = 'John';
const favoriteColor = 'blue';

Hotjar.identify(userId, {
  first_name: firstName,
  color: favoriteColor,
});
```

## Events API

You can also track specific actions taken by your users and send that data to Hotjar via the [Hotjar Events API]("https://help.hotjar.com/hc/en-us/articles/4405109971095-Events-API-Reference").

```javascript
const actionName = 'error';
Hotjar.event(actionName);
```

## Manual URL changes

Depending on how your website routing works, you might need to manually instruct Hotjar when a route change has happened. [More details about URL changes](https://help.hotjar.com/hc/en-us/articles/360034378534).

```javascript
const newPage = '/new';

Hotjar.stateChange(newPage);
```

## CSP

If the project uses [CSP](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP), you can add a special string to your server response headers so that the HotJar script loads without problems

```javascript
// Initializing with `nonce` option:
Hotjar.init(siteId, hotjarVersion, {
  nonce: 'rAnDoM'
});
```

```
Content-Security-Policy: 
  script-src *.hotjar.com 'nonce-rAnDoM'; 
  frame-src *.hotjar.com;
```

## Example

You can find a working example on [GitHub Pages](https://hotjar.github.io/hotjar-js/).
npm package: @hotk/core
Description: Powerful and minimal library for managing global and contextual hotkeys on desktop platforms.
Latest version: 0.0.7

# @hotk/core

[![CI](https://github.com/MiguelRiazaValverde/hotk-core/actions/workflows/CI.yml/badge.svg)](https://github.com/MiguelRiazaValverde/hotk-core/actions/workflows/CI.yml)
[![npm version](https://img.shields.io/npm/v/@hotk/core.svg)](https://www.npmjs.com/package/@hotk/core)

This package provides a minimal utility for registering and unregistering global keyboard shortcuts. It is designed as a low-level component of the @hotk ecosystem and its API may change without notice.

The `init` method accepts a callback to receive hotkey events and an optional boolean parameter (`unref`). If `unref` is set to `true` (the default), the Node.js event loop will not wait for these events to finish before exiting, allowing the process to close normally when there are no other tasks. If `unref` is `false`, the event listener will keep the Node.js process alive, preventing it from exiting until the listener is explicitly destroyed.

| Platform | Supported | Tested |
| -------- | :-------: | :----: |
| Windows  |    ✅     |   ✅   |
| macOS    |    ❓     |   ❌   |
| Linux    |    ❓     |   ❌   |

## Basic usage

```js
import { hotk, KeyCode, Mod } from "@hotk/core";

const manager = hotk();

manager.register([Mod.Control], KeyCode.KeyA);

manager.init(console.log);

setTimeout(() => manager.destroy(), 3000);
```
npm package: @hotkey-input/react
Description: This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
Author: Fayez Nazzal
Latest version: 0.0.30

# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

- Configure the top-level `parserOptions` property like this:

```js
export default {
  // other rules...
  parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json'],
    tsconfigRootDir: __dirname,
  },
}
```

- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list
npm package: @hotkeys/manager
Description: A simple micro-library for defining and dispatching keyboard shortcuts. It has no dependencies.
Author: kenny wong
Latest version: 0.0.1

# Hotkeys

This is the fork of [[hotkeys-js|https://www.npmjs.com/package/hotkeys-js]]

## Install

Install from npm
```bash
npm i --save @hotkeys/manager
```

Import to file:
```javascript
import hotkeysManager from '@hotkeys/manager';
```

## Changes

### addCustomKeyMap

```javascript
// update keyName => keyCode map
hotkeysManager.addCustomKeyMap({
  "numPad#1": 97,
  "numPad#2": 98,
  "numPad#3": 99,
  "=>": 39, 'arrow right' 
});

// use new keys in shotcuts
hotkeysManager('ctrl+numPad#1+=>', () => console.log('hotkey pressed!'));
```

### Bind by key codes

```javascript
// bind just with key codes
hotkeysManager([18, 97, 39], () => console.log('hotkey pressed!'));

// unbind
hotkeysManager.unbind([18, 97, 39]);
```
npm package: @hotlight/react
Description: A command palette, hotkeys and search.
Author: Jonas Arnklint
Latest version: 0.4.7

# Hotlight React

Enable your users to quickly find what they are looking for and perform actions from a command palette in your app or on your website. Hotlight is like Alfred / Quicksilver / Spotlight, but for the web. It is open source and comes with support for multiple frameworks.

Hotlight is based on web components, loaded lazily on the _client_ and available in `React` through this package.

Install it through `npm`:

```bash
npm install @hotlight/react
```

or `yarn`:

```bash
yarn install @hotlight/react
```

## Develop

Run `npm run dev` to open the dev server instance.

## Test

Run `npm run test` to test Hotlight React.
npm package: @hotline/core-plugin
Description: Core Plugin for the Hotline Bot
Author: Aaron Scherer
Latest version: 2.0.15

# @hotline/core-plugin [![Build Status](https://travis-ci.org/DiscordHotline/core-plugin.svg?branch=master)](https://travis-ci.org/DiscordHotline/core-plugin)

This is the core plugin, and a great starting/learning place, for the hotline discord bot.

This uses: [eris-command-framework](https://github.com/aequasi/eris-command-framework).
npm package: @hotline/report-plugin
Description: Report Plugin for the Hotline Bot
Author: Aaron Scherer
Latest version: 1.9.0

# @hotline/report-plugin [![Build Status](https://travis-ci.org/DiscordHotline/report-plugin.svg?branch=master)](https://travis-ci.org/DiscordHotline/report-plugin)

This is the report plugin for the hotline discord bot.

### More Details

https://github.com/DiscordHotline/
npm package: @hotlondon960/aptos-swap-sdk
Description: 🛠 An SDK for building applications on top of Pancakeswap Aptos.
Latest version: 1.0.5

# PancakeSwap Aptos Swap SDK

You can refer to the Uniswap SDK documentation [uniswap.org](https://docs.uniswap.org/sdk/2.0.0/).
npm package: @hotlondon960/eslint-config-pancake
Description: Eslint config for PancakeSwap
Author: RabbitDoge
Latest version: 1.2.1

# eslint-config-pancake

Pancake Eslint config with:

- Airbnb config
- Typescript
- Prettier

## Usage

```
npx install-peerdeps --dev @hotlondon960/eslint-config-pancake
```

Add `"extends": "@hotlondon960/eslint-config-pancake"` to your eslint config file.