open-index/open-npm huggingface dataset:
npm package: @projectdysnomia/dysnomia
Description: A fork of Eris focused on keeping up with the latest Discord API changes.
Author: Project Dysnomia Contributors
Latest version: 0.2.4

Project Dysnomia
====

A fork of [Eris](https://github.com/abalabahaha/eris), a Node.js wrapper for interfacing with Discord, focused on keeping up with the latest Discord API changes.

Installing
----------

You will need Node.js 18+. Voice support requires [additional software](https://github.com/nodejs/node-gyp#installation).

```
npm install --omit=optional @projectdysnomia/dysnomia
```

If you'd like to install the development versions of the library, use the following command instead:
```
npm install --omit=optional "github:projectdysnomia/dysnomia#dev"
```

If you need voice support, remove the `--omit=optional`.

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

```js
const Dysnomia = require("@projectdysnomia/dysnomia");

// Replace TOKEN with your bot account's token
const bot = new Dysnomia.Client("Bot TOKEN", {
    gateway: {
        intents: [
            "guildMessages"
        ]
    }
});

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

bot.on("error", (err) => {
  console.error(err); // or your preferred logger
});

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](examples).

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

- [The official Project Dysnomia server](https://discord.gg/2uUvgJzgCE) is the best place to get support.
- [The GitHub repo](https://github.com/projectdysnomia/dysnomia) is where development primarily happens.
- [The NPM package webpage](https://npmjs.com/package/@projectdysnomia/dysnomia) is, well, the webpage for the NPM package.

License
-------

Refer to the [LICENSE](LICENSE) file.
npm package: @projectdysnomia/libsodium
Description: A minimal libsodium wrapper for Project Dysnomia
Author: Project Dysnomia Contributors
Latest version: 0.1.0

# @projectdysnomia/libsodium
A minimal unified interface for libsodium-based XChaCha20 Poly1305 encryption/decryption.

This is achieved by using the following libraries:
- [`sodium-native`](https://www.npmjs.com/package/sodium-native) uses a native build of libsodium and is preferred when available.
- A heavily stripped down custom build of [libsodium.js](https://www.npmjs.com/package/libsodium) is used as a fallback.
  The differences between libsodium.js and this package are as follows:
    - The WASM binary initiates synchronously, making it better suited for CommonJS environments
    - Only the WASM binary is provided, there is no fallback to JS-based emulation
    - Only `crypto_aead_xchacha20poly1305_ietf_*` (sans `crypto_aead_xchacha20poly1305_ietf_keygen`) and `sodium_init` methods are exposed in the WASM binary

## Installation
```sh
# install with the WASM backend bundled by default
npm install @projectdysnomia/libsodium
# optionally, you may also install sodium-native for better performance
npm install sodium-native
```

## Usage
```js
// auto-selected backend: native is preferred
const mod = require("@projectdysnomia/libsodium");
// native-only
const mod = require("@projectdysnomia/libsodium/native");
// WASM-only
const mod = require("@projectdysnomia/libsodium/wasm");

```
npm package: @projectevergreen/acorn-jsx-esm
Description: Modern, fast React.js JSX parser
Latest version: 0.1.0

# Acorn-JSX

[![Build Status](https://travis-ci.org/acornjs/acorn-jsx.svg?branch=master)](https://travis-ci.org/acornjs/acorn-jsx)
[![NPM version](https://img.shields.io/npm/v/acorn-jsx.svg)](https://www.npmjs.org/package/acorn-jsx)

<a href="https://stand-with-ukraine.pp.ua/"><img src="https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner-direct.svg" width="800"></a>

This is plugin for [Acorn](http://marijnhaverbeke.nl/acorn/) - a tiny, fast JavaScript parser, written completely in JavaScript.

It was created as an experimental alternative, faster [React.js JSX](http://facebook.github.io/react/docs/jsx-in-depth.html) parser. Later, it replaced the [official parser](https://github.com/facebookarchive/esprima) and these days is used by many prominent development tools.

> This is a fork intended to satisfy a specific use case while awaiting the migration of the original package to ESM - https://github.com/acornjs/acorn-jsx/issues/112

## Transpiler

Please note that this tool only parses source code to JSX AST, which is useful for various language tools and services. If you want to transpile your code to regular ES5-compliant JavaScript with source map, check out [Babel](https://babeljs.io/) and [Buble](https://buble.surge.sh/) transpilers which use `acorn-jsx` under the hood.

## Usage

Requiring this module provides you with an Acorn plugin that you can use like this:

```javascript
var acorn = require("acorn");
var jsx = require("@projectevergreen/acorn-jsx-esm");
acorn.Parser.extend(jsx()).parse("my(<jsx/>, 'code');");
```

Note that official spec doesn't support mix of XML namespaces and object-style access in tag names (#27) like in `<namespace:Object.Property />`, so it was deprecated in `acorn-jsx@3.0`. If you still want to opt-in to support of such constructions, you can pass the following option:

```javascript
acorn.Parser.extend(jsx({ allowNamespacedObjects: true }))
```

Also, since most apps use pure React transformer, a new option was introduced that allows to prohibit namespaces completely:

```javascript
acorn.Parser.extend(jsx({ allowNamespaces: false }))
```

Note that by default `allowNamespaces` is enabled for spec compliancy.

## License

This plugin is issued under the [MIT license](./LICENSE).
npm package: @projectevergreen/astro-wcc
Description: An Astro integration for SSR Web Components using WCC
Author: Owen Buckley
Latest version: 0.3.1

# astro-wcc

An [Astro](https://astro.build/) integration for SSR Web Components using [WCC](https://github.com/ProjectEvergreen/wcc).

> See this [demonstration repo](https://github.com/thescientist13/astro-wcc) for an example of using this plugin.

## Usage

1. Install the plugin into your Astro project
    ```sh
    $ npm i -D @projectevergreen/astro-wcc
    ```
1. Then add it to your Astro configuration file
    ```js
    import { defineConfig } from 'astro/config';
    import astroWcc from '@projectevergreen/astro-wcc';

    export default defineConfig({
      integrations: [ astroWcc() ]
    });
    ```
1. You can now use a component in an Astro file
    ```html
    <!-- src/pages/index.astro -->
    <html lang="en">
      <head>
        <script src="../components/greeting.js"></script>
      </head>
      <body>
        <x-greeting></x-greeting>
      </body>
    </html>
    ```

## Caveats

- Currently assumes `<x-${tagName}>` maps to _src/components/${tagName}.js_
- Client hints (e.g. `<x-greeting client:visible>`) are not supported
npm package: @projectevergreen/eleventy-plugin-wcc
Description: An Eleventy plugin for rendering Web Components with WCC.
Author: Owen Buckley
Latest version: 0.4.0

# eleventy-plugin-wcc

## Overview

[**Eleventy**](https://www.11ty.dev/) plugin for rendering native Web Components using [**Web Components Compiler (WCC)**](https://github.com/ProjectEvergreen/wcc).

> _A [starter kit](https://github.com/thescientist13/eleventy-starter-wcc/) for 11ty + WCC is also available._

## Installation

Install from NPM.

```sh
$ npm i -D @projectevergreen/eleventy-plugin-wcc
```

## Configuration

Add the plugin to your _eleventy.js_ config and provide a [`URL`](https://developer.mozilla.org/en-US/docs/Web/API/URL) for all _top level_ custom element definitions you use.
```js
import { wccPlugin } from '@projectevergreen/eleventy-plugin-wcc';

module.exports = function(eleventyConfig) {
  eleventyConfig.addPlugin(wccPlugin, {
    definitions: [
      new URL('./src/js/my-element.js', import.meta.url)
    ]
  });
};
```

## Usage

### 1. Create a Custom Element

Write a custom element like below.  In this case, we are using [Declarative Shadow DOM](https://web.dev/declarative-shadow-dom/).

```js
// src/components/greeting.js
const template = document.createElement('template');

template.innerHTML = `
  <p>Hello from the greeting component!</p>
`;

export default class GreetingComponent extends HTMLElement {
  constructor() {
    super();
    this.attachShadow({ mode: 'open' });
  }

  async connectedCallback() {
    this.shadowRoot.appendChild(template.content.cloneNode(true));
  }
}

customElements.define('x-greeting', GreetingComponent);
```

### 2. Update Configuration

Add your custom element paths to your _.eleventy.js_ config

```js
import { wccPlugin } from '@projectevergreen/eleventy-plugin-wcc';

module.exports = function(eleventyConfig) {
  eleventyConfig.addPlugin(wccPlugin, {
    definitions: [
      new URL('./src/components/my-element.js', import.meta.url)
    ]
  });
};
```

### 3. Use It!

Now in your content or layouts, use the custom element.
```md
<!-- src/index.md -->
# Hello From 11ty + WCC! 👋

<x-greeting></x-greeting>
```

----

Now if you run `eleventy`, you should get an _index.html_ in your _site/_ directory with the custom element content pre-rendered!  🎈
```html
<h2>Hello From 11ty + WCC!</h2>

<x-greeting>
  <template shadowrootmode="open">
    <p>Hello from the greeting component!</p>
  </template>
</x-greeting>
```

## Options

`trimParagraphTagsInMd` (bool, default true) - Trims unexpected `<p>` tags that markdown puts around custom elements [more details](https://github.com/ProjectEvergreen/eleventy-plugin-wcc/issues/8).

> _Please follow along in our [issue tracker](https://github.com/ProjectEvergreen/eleventy-plugin-wcc/issues) or make a suggestion!_
npm package: @projectfunction/excom
Description: Simply your extension's cross-realm communication
Author: Daryl Cecile
Latest version: 1.0.9

# excom
 
Excom is simple library to help simplify communication between your content, background, and popup scripts across your
Chrome extension. Its main goal is to allow you to focus on direct logic without having to worry about managing the sending
and receiving of messages between those realms.


### Getting Started

This library is distributed in esm format only, and exposes 3 handlers for you to use. To get started, install the npm
package:

```shell
yarn add @projectfunction/excom
```

Once installed, you can go ahead and import the relevant handler in each script:

```typescript
// background.js

import {backgroundScriptHandler} from "@projectfunction/excom";
```

```typescript
// popup.js

import {popupScriptHandler} from "@projectfunction/excom";
```

```typescript
// inject.js

import {contentScriptHandler} from "@projectfunction/excom";
```

Each of these handlers are instances of the underlying script communication handler that excom uses to handle communication
between the three realms. To ensure the handlers are ready, simply call the `.tap()` method. This causes the handlers to begin
listening for lifecycle events and messaging. When using in a react-environment, you may need to handle cleanup (i.e. upon unmount);
to do this you can use the `.untap()` method. For example:

```typescript jsx
import {contentScriptHandler} from "@projectfunction/excom";

export default function App(){
	const [count, setCount] = useState(0);
	
	useEffect(()=>{
		contentScriptHandler.tap(); // set up handler
		
		return ()=>{
			contentScriptHandler.untap() // clean up
		}
	}, []);
	
}
```

### Methods

Throughout your extension, you may want to call methods in your background script from your content script or popup; Excom
makes this easy by allowing you to define function-interfaces that script in other realms (i.e. content-script, background-script, popup, etc)
need to call. To do this, you can use the `.registerInterfaces({...})` method of the relevant handlers where you want the methods
to live.

```typescript
// inside background.js 
import {backgroundScriptHandler} from "@projectfunction/excom";

backgroundScriptHandler.tap(); // make sure this is done before interfaces are registered

backgroundScriptHandler.registerInterfaces({
	openTab: async function(url) {
		let tab = await chrome.tabs.create({ url, active: false });
		console.log('tab created from the background script', tab.id);
		return 42; // return some value if needed
	}
});

```

Once defined, that method can then be called from other realms:

```typescript
// inside inject.js 
import {contentScriptHandler} from "@projectfunction/excom";

let response = await contentScriptHandler.backgroundMethods.openTab('https://google.com');

// expect(response).toEqual(42);
```

> **Warning**
> All functions to be exposed across realms should be async to avoid race conditions!
npm package: @projecthoneycomb/cli
Description: @projecthoneycomb/cli =====================
Latest version: 0.0.1

@projecthoneycomb/cli
=====================



[![oclif](https://img.shields.io/badge/cli-oclif-brightgreen.svg)](https://oclif.io)
[![Version](https://img.shields.io/npm/v/@projecthoneycomb/cli.svg)](https://npmjs.org/package/@projecthoneycomb/cli)
[![Downloads/week](https://img.shields.io/npm/dw/@projecthoneycomb/cli.svg)](https://npmjs.org/package/@projecthoneycomb/cli)
[![License](https://img.shields.io/npm/l/@projecthoneycomb/cli.svg)](https://github.com/projecthoneycomb/cli/blob/master/package.json)

<!-- toc -->
* [Usage](#usage)
* [Commands](#commands)
<!-- tocstop -->
# Usage
<!-- usage -->
```sh-session
$ npm install -g @projecthoneycomb/cli
$ comb COMMAND
running command...
$ comb (-v|--version|version)
@projecthoneycomb/cli/0.0.1 darwin-x64 node-v12.6.0
$ comb --help [COMMAND]
USAGE
  $ comb COMMAND
...
```
<!-- usagestop -->
# Commands
<!-- commands -->
* [`comb hello [FILE]`](#comb-hello-file)
* [`comb help [COMMAND]`](#comb-help-command)

## `comb hello [FILE]`

describe the command here

```
USAGE
  $ comb hello [FILE]

OPTIONS
  -f, --force
  -h, --help       show CLI help
  -n, --name=name  name to print

EXAMPLE
  $ comb hello
  hello world from ./src/hello.ts!
```

_See code: [src/commands/hello.ts](https://github.com/projecthoneycomb/cli/blob/v0.0.1/src/commands/hello.ts)_

## `comb help [COMMAND]`

display help for comb

```
USAGE
  $ comb help [COMMAND]

ARGUMENTS
  COMMAND  command to show help for

OPTIONS
  --all  see all commands in CLI
```

_See code: [@oclif/plugin-help](https://github.com/oclif/plugin-help/blob/v2.2.0/src/commands/help.ts)_
<!-- commandsstop -->