open-index/open-npm huggingface dataset:
npm package: @flamatoken/sdk
Description: 🛠 An SDK for building applications on top of IgniSwap.
Latest version: 3.0.8

# IgniSwap SDK

🛠 An SDK for building applications on top of IgniSwap.

## Running tests

To run the tests, follow these steps. You must have at least node v10 and [yarn](https://yarnpkg.com/) installed.

First clone the repository:

```sh
git clone https://github.com/Uniswap/igniswap-sdk.git
```

Move into the uniswap-sdk working directory

```sh
cd igniswap-sdk/
```

Install dependencies

```sh
yarn install
```

Run tests

```sh
yarn test
```

You should see output like the following:

```sh
yarn run v1.22.4
$ tsdx test
 PASS  test/constants.test.ts
 PASS  test/pair.test.ts
 PASS  test/fraction.test.ts
 PASS  test/miscellaneous.test.ts
 PASS  test/entities.test.ts
 PASS  test/trade.test.ts

Test Suites: 1 skipped, 6 passed, 6 of 7 total
Tests:       3 skipped, 82 passed, 85 total
Snapshots:   0 total
Time:        5.091s
Ran all test suites.
✨  Done in 6.61s.
```
npm package: @flambo/api-client
Description: [![npm version](https://img.shields.io/npm/v/@flambo/api-client.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/api-client)
Latest version: 0.1.2

# flambo API client

[![npm version](https://img.shields.io/npm/v/@flambo/api-client.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/api-client)
npm package: @flambo/bot
Description: [![npm version](https://img.shields.io/npm/v/@flambo/bot.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/bot)
Latest version: 0.1.4

# flambo bot

[![npm version](https://img.shields.io/npm/v/@flambo/bot.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/bot)
npm package: @flambo/cli
Description: [![npm version](https://img.shields.io/npm/v/@flambo/cli.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/cli)
Latest version: 0.1.2

# flambo CLI

[![npm version](https://img.shields.io/npm/v/@flambo/cli.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/cli)
npm package: @flambo/source-meetup
Description: [![npm version](https://img.shields.io/npm/v/@flambo/source-meetup.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/source-meetup)
Latest version: 0.1.2

# flambo Meetup source

[![npm version](https://img.shields.io/npm/v/@flambo/source-meetup.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/source-meetup)
npm package: @flambo/source-rss
Description: [![npm version](https://img.shields.io/npm/v/@flambo/source-rss.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/source-rss)
Latest version: 0.1.2

# flambo RSS source

[![npm version](https://img.shields.io/npm/v/@flambo/source-rss.svg?style=flat-square)](https://www.npmjs.com/package/@flambo/source-rss)
npm package: @flamedb/next
Description: Easy to use wrapper for Firebase Firestore. A next gen version of FlameDB
Latest version: 1.0.8

# @flamedb/next

The next version for FlameDB. A lightweight firebase firestore wrapper with a compact and complete features.
FlameDB provides methods that are easy to understand and beginner friendly. Inspired by quick.db, FlameDB methods are very similar except that FlameDB works with a cloud database (firebase firestore).

## Installation
1. run `npm install @flamedb/next` or `yarn add @flamedb/next`.
2. You can start working!

## Examples
```js
const FlameDB = require('@flamedb/next');
const db = new FlameDB();

db.on('connect', async () => {

    // Create a new collection with a doc named 'repyh' that has a value of below.
    await db.create('user.repyh', { dumb: true });

    // Set an existing document and set the 'dumb' property to false (bc Im not dumb).
    await db.set('user.repyh.dumb', false);

    // Get the value for 'dumb' property which in this case will return false
    await db.get('user.repyh.dumb');

});

db.connect(service_account);
```

## Service Account
Getting service account is quite easy.
1. Go to your firebase console and open 'Project Settings'.
2. Go to 'Service accounts' tab and click 'create new private key'.
3. After downloading the key, we'll only need 3 things from the json file; client_email, project_id, and private_key.
4. Next, set the service account in a secret folder (especially private_key, you can use .env file to store).
5. Do as below
```js
db.connect({
    privateKey: '...', // Your private key.
    clientEmail: '...', // Your client email.
    projectId: '...' /// Your project id.
})
```

## Support & Bugs
Please wait until further information.
npm package: @flameinthedark/go-dave
Description: DAVE session management and WebRTC frame encryption for browser and Electron apps
Latest version: 1.1.0

# @flameinthedark/go-dave

`@flameinthedark/go-dave` is the browser and Electron build of `go-dave`. It bundles `go-dave.wasm` and exposes a small DAVE session API for WebRTC insertable streams.

Protocol reference: [daveprotocol.com](https://daveprotocol.com/)

Use it to:

- create and advance DAVE/MLS sessions
- exchange key material with your gateway or voice server
- encrypt outgoing encoded frames before transport encryption
- decrypt incoming encoded frames after transport decryption
- show verification codes and fingerprints to users

## Install

```bash
npm install @flameinthedark/go-dave
```

The package already includes `go-dave.wasm` and `wasm_exec.js`.

## Quick Start

Most integrations only need a single session object and a handful of methods.

```ts
import { loadGoDave } from '@flameinthedark/go-dave'

// Load the bundled WASM runtime once for the whole app.
const GoDave = await loadGoDave()

// Create one session per user in the voice channel.
const session = GoDave.createSession(
  GoDave.DAVE_PROTOCOL_VERSION,
  userId,
  channelId,
)

// Set the external sender announced by the gateway.
session.setExternalSender(externalSenderBuffer)

// Send this key package to your gateway or voice server.
const keyPackage = session.getSerializedKeyPackage()

// Apply proposals as the roster changes.
const result = session.processProposals(
  GoDave.ProposalsOperationType.APPEND,
  proposalsBuffer,
  recognizedUserIds,
)

// Apply the commit produced for this session, or a welcome if you joined through one.
if (result.commit) {
  session.processCommit(result.commit)
}
if (welcomeBuffer) {
  session.processWelcome(welcomeBuffer)
}

// Encrypt outgoing frames and decrypt incoming frames once the session is ready.
if (session.getState().ready) {
  const encryptedPacket = session.encryptOpus(outgoingPacket)
  if (encryptedPacket) {
    console.log('send encrypted packet', encryptedPacket)
  }

  const decryptedPacket = session.decrypt(
    remoteUserId,
    GoDave.MediaType.AUDIO,
    incomingPacket,
  )
  if (decryptedPacket) {
    console.log({ keyPackage, decryptedPacket })
  }
}
```

## Notes

- `loadGoDave(...)` is single-flight and safe to call more than once.
- `encrypt(...)`, `encryptOpus(...)`, and `decrypt(...)` return `Uint8Array | null`.
- Recoverable frame-path failures are logged with `console.warn(...)`.
- Call `session.dispose()` when you are done with a session.

## Guides

- [Full browser and Electron guide](https://github.com/FlameInTheDark/go-dave/blob/main/docs/wasm.md)
- [Overview and concepts](https://github.com/FlameInTheDark/go-dave/blob/main/docs/overview.md)
- [Gateway packet guide](https://github.com/FlameInTheDark/go-dave/blob/main/docs/gateway-packets.md)
- [Insertable Streams and runtime notes](https://github.com/FlameInTheDark/go-dave/blob/main/docs/insertable-streams.md)
- [TypeScript definitions](https://github.com/FlameInTheDark/go-dave/blob/main/wasm/index.d.ts)
npm package: @flameland/flame
Description: An extensible web component framework for the back end.
Author: Zack Pace
Latest version: 0.0.12

# Flame
An extensible web component framework for the back end.

```
npm i --save @flameland/flame
```

> **NOTE** This project is currently still in development, so you may encounter some issues with it.  If you do, please report it as soon as possible.  Thank you :)

# Why Flame?
- ## Easy to Switch
If you're already using ExpressJS, it's easy to get started with Flame with Flame's Express middleware:

```js
const express = require('express');
const { FlameMiddleware } = require('@flameland/flame');

const app = express();
app.engine('flame', FlameMiddleware);
app.set('view engine', 'flame');

app.get('/', (req, res) => {
	res.render('view.flame', {});
});
```

- ## No New Language
Flame views are just plain Node.js JavaScript, meaning you don't have to learn any new syntax to make an awesome web application:
```js
class MyPage extends Flame.Component {
	render() {
		return `Hello, world!`;
	}
}

module.exports = new MyPage();
```
npm package: @flamescape/poller
Description: A bit like setInterval(), but with a slightly different API and slightly different behaviour.
Author: @flamescape
Latest version: 1.0.0

# @flamescape/poller

A bit like `setInterval()`, but with a slightly different API and slightly different behaviour.

## Why?

- setInterval does not provide an "air-gap" time between calls, making it possible to enter callback runaway. Poller `await`s on the result of the given callback before scheduling the next call.
- Stopping a poller instance returns a promise which resolves once any outstanding callbacks have resolved.

## Usage

```js
import {createPoller} from '@flamescape/poller';

const poller = createPoller(() => {
    // do something every 1000ms
, 1000);

// later...
await poller.stop();
```

## API

### createPoller(callback, interval, options)

- `callback`: a function to call every `interval` ms.
- `interval`: the number of milliseconds "air-gap" interval between calls of the callback function.
- `options`:
    - `autoStart`: if true, equivalent to calling `.start()` on the poller instance immediately after creation.

returns a `Poller` instance.

### Poller#start()

Starts the poller if not already started. If already started, this is a no-op.

### Poller#stop() : Promise

Stops polling and returns a promise which resolves once any pending async callback completes.

## Notes

- Poller will not attempt to handle any errors which are thrown from within your callback. You should ensure that your callback cannot throw.

## License

MIT
npm package: @flamesx128/nextlog
Description: This library adds different console registers.
Author: FlamesX-128
Latest version: 0.2.1

# NextLog
This library adds different console registers.

## Examples

```js
log.error("New Error!");
// output: [15/10/2021] [19:30:58] [ERR] New Error!

log.ok("Ok");
// output: [15/10/2021] [19:30:58] [ERR] Ok

log.print("Hello world!");
// output: [15/10/2021] [19:30:58] [ERR] Hello world!

log.warn("New Warn!");
// output: [15/10/2021] [19:30:58] [ERR] New Warn!
```

![image](https://user-images.githubusercontent.com/78381898/137566752-c4cb813b-75e9-4cd2-8617-b0e4ddf76220.png)
npm package: @flameui/styles
Description: Utilities for HTML Style
Latest version: 0.0.2

# @flameui/styles

## Installation

```sh
npm i -g @flameui/styles
```

OR

```sh
yarn add @flameui/styles
```

## Functions

```ts
function applyStyle<Element extends HTMLElement>(element: Element, styles: HTMLStyle, remove = true): Element
```

This function applies the style properties specified in the `styles` object to `element.style`.

If the `remove` parameter is set to `true`, style properties with `undefined` or `null` values will be removed from `element.style`.