open-index/open-npm huggingface dataset:
npm package: @peer_iq/broccoli-pegjs
Description: PEG.js filter for Broccoli
Author: Gordon L. Hempton
Latest version: 1.0.0

# broccoli-pegjs

A PEG.js filter for Broccoli.

## Installation

```bash
npm install --save-dev broccoli-pegjs
```

## Usage

```js
var peg = require('broccoli-pegjs');
tree = peg(tree, options);
```

## Options

### Custom Wrapper

It is possible to wrap the generated parser in any code you want:

```
tree = peg(tree, {
  wrapper: function (src, parser) {
    return 'var Parser = ' + parser + ";\nvar parse = Parser.parse, SyntaxError = Parser.SyntaxError;\nexport {SyntaxError, parse};\nexport default parse;";
  }
});
```
npm package: @peer_iq/ember-cli-pegjs
Description: Use this module to preprocess any .pegjs grammar to generate parsers.
Author: asaf@indexia.co
Latest version: 1.0.1

# ember-cli-pegjs

An [ember-cli](https://github.com/stefanpenner/ember-cli) addon for generating [PegJS](https://github.com/dmajda/pegjs) parser from grammar file.

## Installation

```bash
npm install --save-dev ember-cli-pegjs
```

## Usage

By default this addon will generate a parser for every file with the _pegjs_ extension, the generated parser 
extension is _js_ and will be located in the same folder as the grammar file.

The parser is exported as an ES6 module and can be simply imported as any other Ember CLI file.

You can control how the parser code is exported by specifying options using the pegOptions config property:
```
var app = new EmberApp({
  ...
  pegOptions: {
    wrapper: function (src, parser) {
      return 'var Parser = ' + parser + ";\nvar parse = Parser.parse, SyntaxError = Parser.SyntaxError;\nexport {SyntaxError, parse};\nexport default parse;";
    }
  }
});
```
npm package: @peeramid-labs/multipass
Description: Contracts for public cross domain username query
Author: Tim Pechersky
Latest version: 0.3.8

# Multipass

Multipass is a universal, decentralized, open source protocol designed to facilitate public identity trough a frictionless cross-domain user data lookup. 

![multipass-logo-512](https://github.com/user-attachments/assets/72625d2b-c195-4ee2-b278-5b27e6330625)


**With multipass you are able to answer following questions**
- _"What's @Bob at telegram handle on discord"?_
- _"I just saw an activity by `0xdeadcafee...101` for my dApp, what's handle of user on @discord?_
- _"What's @Bob EOA wallet on EVM?_

**Use cases**

- **Rich UX for your dApp notification system**: No longer address names in event noficiations. Tag your users instead!
- **Cross platform social graph**: See social graph beyond your platform. 
- **Anti-bot measures**: require users to verify on other platforms
- **Cross platform anti-fraud measures**: Get notified if other platforms ban users
- **Off-chain account abstraction**": Your service may use web2 auth tokens or signed messages from your platform to associate it with registred account on chain. E.g pay users transaction and use web2 signed message as paymaster validation proof.
- **Create token gated access to your identity**: Imagine you have a public twitter account. We can associate your 

## Project status: Alpha

We are workin on setting up a token and deploying governing body as a DAO. 

If you want to be up to date and not miss a thiing, please 
- subscribe to our twitter: https://x.com/peeramid_labs
- join our discord: https://discord.gg/EddGgGUuWC 

## Contributing

We welcome contributions from the community to help improve and enhance Multipass. If you're interested in contributing, please refer to our [contribution guidelines](https://github.com/peeramid/multipass/blob/main/CONTRIBUTING.md).

## License

Multipass is released under the [MIT License](https://github.com/peeramid/multipass/blob/main/LICENSE).

## Contact

If you have any security findings, questions or feedback regarding Multipass, please reach out to us at [contracts@peeramid.xyz](mailto:contracts@peeramid.xyz).

## Support 

Please support us by hitting "sponsor" button or by going for gitcoin page:

https://explorer.gitcoin.co/#/projects/0x9aa1813681cbc4c7acdad3f7687ee68b6c21a055f2df0d771551ad3d0a9e9d4d
npm package: @peeraop21/v-calendar-buddhist
Description: A calendar(buddhist year) and date picker plugin for Vue.js.
Author: Peera
Latest version: 1.0.2

# VCalendar(buddhist year) Plugin for Vue 3

A calendar(buddhist year) and date picker plugin for [Vue.js](https://vuejs.org) (requires version 3.2+).


## Install Plugin

### NPM

```shell
npm install @peeraop21/v-calendar-buddhist
```

### Yarn

```shell
yarn add @peeraop21/v-calendar-buddhist
```

## Use Plugin

```js
import VCalendar from '@peeraop21/v-calendar-buddhist';
import '@peeraop21/v-calendar-buddhist/style.css';

const app = createApp(App)
app.use(VCalendar)
app.mount('#app')
```
npm package: @peerasak-u/send-to-kindle
Description: A CLI tool for sending files to your Kindle via email using Apple Mail.app on macOS
Author: peerasak-u
Latest version: 1.0.11

# send-to-kindle

A CLI tool for sending files to your Kindle via email using Apple Mail.app on macOS.

## Install

```bash
# via bunx
bunx @peerasak-u/send-to-kindle --to=your-kindle@kindle.com --from=your-email@gmail.com --file=/path/to/document.pdf

# or install globally
bun install -g @peerasak-u/send-to-kindle
send-to-kindle --to=your-kindle@kindle.com --from=your-email@gmail.com --file=/path/to/document.pdf
```

## Usage

```bash
# Show help
bunx @peerasak-u/send-to-kindle --help

# Send a file to Kindle
bunx @peerasak-u/send-to-kindle --to=your-kindle@kindle.com --from=your-email@gmail.com --file=/path/to/document.pdf

# Send with custom subject
bunx @peerasak-u/send-to-kindle --to=your-kindle@kindle.com --from=your-email@gmail.com --file=/path/to/document.pdf --subject="Monthly Report"

# Send with message body
bunx @peerasak-u/send-to-kindle --to=your-kindle@kindle.com --from=your-email@gmail.com --file=/path/to/document.pdf --message="Enjoy reading!"
```

## Options

| Option | Required | Description |
|--------|----------|-------------|
| `--to` | Yes | Recipient email address (e.g., your Kindle email) |
| `--from` | Yes | Sender email address (must be approved in your Amazon account) |
| `--file` | Yes | Path to the file to attach |
| `--subject` | No | Subject prefix (default: "Daily News") |
| `--message` | No | Body message for the email |
| `--help` | No | Show help message |
| `--version` | No | Show version number |

## Development

This project was created using `bun init` in bun v1.2.19. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
npm package: @peerbit/clock-service
Description: Clock signing
Author: dao.xyz
Latest version: 3.2.48

# ClockService

## 🚧 Experimental state 🚧
This module can sign entries to verify that their timestamps are set correctly.

See the [test](./src/__tests__/index.test.ts) for examples.

Nodes running this program will sign entries if their timestamp is not too far from "now". 
Hence, only use this program with an identity dedicated for this job since peers can send any entry to be signed (i.e. use dedicated nodes for this)
npm package: @peerbit/document
Description: Document store implementation
Author: dao.xyz
Latest version: 13.0.24

# Documents

Distributed document store.

This store is built on top of the base store. This store allows for type-safe document storage and retrieval accross peers. 

As of now, go through the [tests](./src//__tests__/index.integration.test.ts) for documentation on how to use the module.



Example 
```typescript 
import { field, option, serialize, variant } from "@dao-xyz/borsh";
import { Program } from "@peerbit/program";
import { Peerbit } from "peerbit";
import {
	Documents,
	DocumentIndex,
	SearchRequest,
	StringMatch,
	StringMatchMethod,
	Results,
} from "@peerbit/document";


@variant("document")
class Document {
    @field({ type: "string" })
    id: string;

    @field({ type: option("string") })
    name?: string;

    @field({ type: option("u64") })
    number?: bigint;

    constructor(opts?: Document) {
        if (opts) {
            Object.assign(this, opts);
        }
    }
}

@variant("test_documents")
class TestStore extends Program {
    @field({ type: Documents })
    docs: Documents<Document>;

    constructor(properties?: { docs: Documents<Document> }) {
        super();
        if (properties) {
            this.docs = properties.docs;
        }
    }
    async open(): Promise<void> {
        await this.docs.open({ 
			type: Document, 
			index: {
				fields: (obj) => obj // here you can filter and transform what fields you want to index
			}})
    }
}

// later 

const peer = await Peerbit.create ({libp2p: your_libp2p_instance})
const store = peer.open(new TestStore());
console.log(store.address) /// this address can be opened by another peer 


// insert
let doc = new Document({
    id: "1",
    name: "hello world",
    number: 1n,
});
let doc2 = new Document({
    id: "2",
    name: "hello world",
    number: 2n,
});

let doc3 = new Document({
    id: "3",
    name: "foo",
    number: 3n,
});

await store.docs.put(doc);
await store.docs.put(doc2);
await store.docs.put(doc3);


// search for documents from another peer
const peer2 = await Peerbit.create ({libp2: another_libp2p_instance})
const store2 = peer2.open(store.address);

let responses: Document[] = await store2.docs.index.search(
    new SearchRequest({
        query: [
          new StringMatch({
                key: "name",
                value: "ello",
				method: StringMatchMethod.contains
            }),
        ],
    })
);
expect(responses]).to.have.length(2);
expect(responses.map((x) => x.value.id)).to.deep.equal(["1", "2"]);
```
npm package: @peerbit/identity-access-controller
Description: Access controller that operates on a DB
Author: dao.xyz
Latest version: 6.0.24

# "Chain agnostic" Access Controller
## 🚧 Experimental state 🚧

An access controller that supports different layers of control and fallbacks. 

- A store containing ACL information, for example what public key can read and write
- A distributed relation store that lets you use linked devices to get access
- A fallback trusted network access controller that lets you have access if you are trusted by the root trust identity


As of now, go through the tests for documentation.