open-index/open-npm huggingface dataset:
npm package: @pantocode/random-messages
Description: I don't know what to write for the first commit
Author: Andres Pantoja
Latest version: 1.0.1


# random-messages

Whenever I start a new project, I don't know what to write for the first commit. After doing a “git init” there is technically nothing there...

## Install

```npm
npm install -g random-msg
```

# Usage

```bash
random-msg
```

# Contributing
If someone wants to add or improve something, I invite you to collaborate directly in this repository: [random-msg](https://github.com/platzi/npm-random-msg)

# License
random-msg is released under the [MIT License](https://opensource.org/licenses/MIT).# random-messages
npm package: @pantograph/design-tokens
Description: Figma design tokens for Pantograph
Author: sedmedgh
Latest version: 0.0.3

# @pantograph/design-tokens

Design tokens exported from Figma for the Pantograph project.
- use fine-grained Git token
- use npm bypass token 
- use [TokensBrücke Figma extension](https://www.figma.com/community/plugin/1254538877056388290/tokensbrucke) by belo configs:

```json
{
  "repo": "pantograph-design-tokens",
  "owner": "mahdaad-group",
  "path": "src/designTokens.json",
  "file": "main",
  "commit": "figma-token-update"
}
```

## Installation

```bash
npm install @pantograph/design-tokens
```

## Usage

```javascript
// Import design tokens
import { designTokens } from '@pantograph/design-tokens';

// Import types
import { type Langs, type Themes, type GrayScales } from '@pantograph/design-tokens';

// Or import everything
import { designTokens, type Langs, type Themes, type GrayScales } from '@pantograph/design-tokens';
```

## Available Exports

### Design Tokens
- `designTokens`: Complete design tokens JSON object

### Constants
- `langs`: Available languages `['fa', 'en']`
- `themes`: Available themes `['oktuple', 'claytap', 'agility', 'pantograph', 'primeplanet']`
- `grayScales`: Available gray scales `['arsenic', 'cool', 'warm', 'neutral']`

### Types (Union Types)
- `Langs`: `'fa' | 'en'`
- `Themes`: `'oktuple' | 'claytap' | 'agility' | 'pantograph' | 'primeplanet'`
- `GrayScales`: `'arsenic' | 'cool' | 'warm' | 'neutral'`

## Build

The package includes a build system that automatically generates TypeScript types from the design tokens JSON file. To rebuild after updating `designTokens.json`:

```bash
npm run build
```

## Author

**sedmedgh** - [sedmedgh@gmail.com](mailto:sedmedgh@gmail.com)

## License

This project is licensed under the MIT License.

## Direct JSON Access

You can also access the raw JSON file directly:

```javascript
import { designTokens } from '@pantograph/design-tokens';
```
npm package: @pantograph/pattern-vue
Description: <p align="center">   <img src="./public/logo.svg" alt="Pantograph Logo" width="160" /> </p>
Author: sedmedgh
Latest version: 0.0.15

<p align="center">
  <img src="./public/logo.svg" alt="Pantograph Logo" width="160" />
</p>

# @pantograph/pattern-vue

Pantograph's Vue 3 component library, built with TypeScript and token-based design. Ready to use in your apps with light/dark token switching and simple, consistent APIs.

## Install
```bash
npm i @pantograph/pattern-vue
```

## Quick usage
```vue
<script setup lang="ts">
import { ref } from 'vue'
import { InputPassword } from '@pantograph/pattern-vue'
import '@pantograph/styles'

const password = ref('')
const isVisible = ref(false)
</script>

<template>
  <InputPassword
    v-model="password"
    v-model:visible="isVisible"
    placeholder="Enter your password"
  />
</template>
```

## Components

### InputPassword

A password input component with built-in visibility toggle functionality.

**Features:**
- Built-in eye icon to toggle password visibility
- Dual v-model support (`v-model` for value, `v-model:visible` for visibility state)
- All Input component props, slots, and events are supported
- Accessible with proper ARIA labels

**Usage:**
```vue
<script setup lang="ts">
import { ref } from 'vue'
import { InputPassword } from '@pantograph/pattern-vue'

const password = ref('')
</script>

<template>
  <InputPassword
    v-model="password"
    placeholder="Enter your password"
    allowClear
  />
</template>
```
npm package: @pantograph/vue
Description: <p align="center">   <img src="./public/logo.svg" alt="Pantograph Logo" width="160" /> </p>
Author: sedmedgh
Latest version: 0.34.38

<p align="center">
  <img src="./public/logo.svg" alt="Pantograph Logo" width="160" />
</p>

# @pantograph/vue

Pantograph's Vue 3 component library, built with TypeScript and token-based design. Ready to use in your apps with light/dark token switching and simple, consistent APIs.

## Install
```bash
npm i @pantograph/vue
```

## Quick usage
```vue
<script setup lang="ts">
import { Button } from '@pantograph/vue'
import '@pantograph/styles'
</script>

<template>
  <Button>Click me</Button>
</template>
```

## Documentation
For full documentation and live examples, visit the Pantograph docs:

- Docs: [Introduction & Stories](https://panto.stg.bounteco.com/story/src-story-introduction-story-js)
npm package: @pantsme/ethgasbot
Description: Simple Discord bot that returns the current Ethereum gas price from Gasnow.org
Author: Antonio Savage
Latest version: 0.0.35

## Eth Gas Bot

Simple Discord bot that publishes the Ethereum gas price fetched from [Gasnow](https://gasnow.org)

### Usage

* Create a .env file in the root directory with your Discord bot token
* Either create a Docker image using `docker build .` or start the bot with `npm run start`
* On your server that you invited the bot to, type `.gas` in a channel and it will return the prices
  
  #### Example response
```
gas bot BOT Today at 6:41 PM
rapid: 221000000000
fast: 209000001459
standard: 170000000000
slow: 151250000000
```
npm package: @panukresko/hardhat
Description: Foundry's hardhat plugin
Latest version: 0.3.1

# hardhat

Aggregated foundry hardhat plugin

## Installation

See in each plugin

- [anvil](../hardhat-anvil/README.md)
- [forge](../hardhat-forge/README.md)
- [foundryup](../easy-foundryup/README.md)

## LICENSE

- MIT license ([LICENSE](LICENSE) or https://opensource.org/licenses/MIT)
npm package: @panukresko/hardhat-anvil
Description: Hardhat plugin for managing Anvil
Latest version: 0.3.1

# hardhat-anvil

This Hardhat plugin automatically starts and stops [Anvil](https://github.com/foundry-rs/foundry/tree/master/anvil) when running tests or scripts.

## What

This plugin creates a network named `anvil`. When this network is used, it can either connect to a running `anvil` instance or launch a new server automatically before running tests and scripts.

## Installation

### Anvil binary

See [anvil installation](https://github.com/foundry-rs/foundry/tree/master/anvil#installation)

### Plugin

```bash
npm install --save-dev @foundry-rs/hardhat-anvil
```

And add the following statement to your `hardhat.config.js`:

```js
require("@foundry-rs/hardhat-anvil");
```

Or, if you are using TypeScript, add this to your `hardhat.config.ts`:

```js
import "@foundry-rs/hardhat-anvil";
```

## Tasks

This plugin hooks into the `test`.

## Environment extensions

This plugin adds a `waffle` object to the Hardhat Runtime Environment. This object has all the Waffle functionality, already adapted to work with Hardhat.

This is a slightly modified, `anvil` compatible version of [`@nomiclabs/hardhat-waffle`](https://github.com/NomicFoundation/hardhat/tree/master/packages/hardhat-waffle).

## Usage

Once `anvil` is installed you can simply run it and configure it via the CLI.

Once installed, you can build your tests almost like in Waffle.

Instead of importing things from `ethereum-waffle`, you access them from the `waffle` property of the Hardhat Runtime Environment.

## Configuration

You can set any of the [Anvil's options](https://github.com/foundry-rs/foundry/tree/master/anvil) (or `anvil --help`) through the `anvil` network config.

**Note: currently only default settings are used if `launch: true`. All other configs are currently ignored**

It's recommend to spawn `anvil` manually in a separate shell, see also [Foundry repo](https://github.com/foundry-rs/foundry/tree/master/anvil)

This example sets a larger block gas limit and the default balance of Anvil's accounts.

```js
module.exports = {
  defaultNetwork: "anvil",
    anvil: {
      url: "http://127.0.0.1:8545/",
      launch: false, // if set to `true`, it will spawn a new instance if the plugin is initialized, if set to `false` it expects an already running anvil instance
    }
  }
};
```

By default, the `anvil` object will be configured as

```js
{
  hdPath: "m/44'/60'/0'/0/",
  mnemonic: 'test test test test test test test test test test test junk',
  url: 'http://127.0.0.1:8545/',
  launch: true,
  accounts: {
    mnemonic: 'test test test test test test test test test test test junk',
    path: "m/44'/60'/0'/0/"
  }
}
```

## LICENSE

- MIT license ([LICENSE](LICENSE) or https://opensource.org/licenses/MIT)
npm package: @panukresko/hardhat-forge
Description: Hardhat plugin for foundry's forge
Latest version: 0.3.1

# hardhat-forge

This Hardhat plugin is for [forge](https://github.com/foundry-rs/foundry/tree/master/forge).

## What

This plugin provides bindings for `forge` commands as hardhat tasks.

## Installation

```bash
npm install --save-dev @foundry-rs/hardhat-forge
```

And add the following statement to your `hardhat.config.js`:

```js
require("@foundry-rs/hardhat-forge");
```

Or, if you are using TypeScript, add this to your `hardhat.config.ts`:

```js
import "@foundry-rs/hardhat-forge";
```

## Tasks

This plugin provides the following tasks:

- "forge::build" for "`forge build`
- "forge::test" for "`forge test`

## Configuration

See [Foundry](https://github.com/foundry-rs/foundry).

## LICENSE

- MIT license ([LICENSE](LICENSE) or https://opensource.org/licenses/MIT)
npm package: @panutat/kinetica-graph-viz
Description: Kinetica DB library for graph visualization
Author: Pat Khunachak
Latest version: 1.0.13

<h2>Kinetica Graph Visualization Library</h2>
Visualize graph data fom a Kinetica database

## Installation

```
npm install --save @panutat/kinetica-graph-viz
```

## Usage

### npm

```javascript
import KineticaGraphViz from "@panutat/kinetica-graph-viz";
const kGraphViz = new KineticaGraphViz("my_graph");

kGraphViz
  .connect("http://127.0.0.1:9191", {
    username: "admin",
    password: "password",
  })
  .nodes("graph.social_ids_nodes", ["id", "name"])
  .edges("graph.social_ids_edges", ["node1", "node2"])
  .limit(1000)
  .graph((graph) => {
    graph
      .cooldownTicks(50)
      .backgroundColor("#00000000")
      .nodeVal(() => Math.random() * 15)
      .nodeLabel((node) => `Node ${node.id}`)
      .nodeColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
      .linkColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
      .linkWidth(2);
  })
  .render();
```

### self-host/cdn

```javascript
<script src="build/index.js"></script>;

const KineticaGraphViz = window.KineticaGraphViz.default;
const kGraphViz = new KineticaGraphViz("my_graph");

kGraphViz
  .connect("http://127.0.0.1:9191", {
    username: "admin",
    password: "password",
  })
  .data("graph.nodes_edges", ["EDGE_NODE1_ID", "EDGE_NODE2_ID"])
  .limit(1000)
  .graph((graph) => {
    graph
      .cooldownTicks(50)
      .backgroundColor("#00000000")
      .nodeVal(() => Math.random() * 15)
      .nodeLabel((node) => `Node ${node.id}`)
      .nodeColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
      .linkColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
      .linkWidth(2);
  })
  .render();
```
npm package: @panutat/react-kinetica-graph-viz
Description: Kinetica DB React component for graph visualization
Author: Pat Khunachak
Latest version: 1.0.13

<h2>Kinetica Graph Visualization React Component Library</h2>
React component to visualize graph data fom a Kinetica database

## Installation

```
npm install --save @panutat/react-kinetica-graph-viz
```

## Usage

```javascript
import { KineticaGraphViz } from "@panutat/react-kinetica-graph-viz";
import "./App.css";

function App() {
  return (
    <KineticaGraphViz
      id="my_graph"
      server="http://127.0.0.1:9191"
      username="admin"
      password="password"
      node_table="graph.social_ids_nodes"
      node_columns={["id", "name"]}
      edge_table="graph.social_ids_edges"
      edge_columns={["node1", "node2"]}
      limit={800}
      graph_config={(graph) => {
        graph
          .cooldownTicks(50)
          .backgroundColor("#00000000")
          .nodeVal(() => Math.random() * 15)
          .nodeLabel((node) => `Node ${node.id}`)
          .nodeColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
          .linkColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
          .linkWidth(2);
      }}
    />
  );
}

export default App;
```

```javascript
import { KineticaGraphViz } from "@panutat/react-kinetica-graph-viz";
import "./App.css";

function App() {
  return (
    <KineticaGraphViz
      id="my_graph"
      server="http://127.0.0.1:9191"
      username="admin"
      password="password"
      data_table="graph.multi_out_table"
      data_columns={["EDGE_NODE1_ID", "EDGE_NODE2_ID"]}
      limit={800}
      graph_config={(graph) => {
        graph
          .cooldownTicks(50)
          .backgroundColor("#00000000")
          .nodeVal(() => Math.random() * 15)
          .nodeLabel((node) => `Node ${node.id}`)
          .nodeColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
          .linkColor(() => (Math.random() > 0.5 ? "#4c00b0" : "#FF00FF"))
          .linkWidth(2);
      }}
    />
  );
}

export default App;
```
npm package: @panva/asn1.js
Description: ASN.1 encoder and decoder for Node.js with no dependencies (fork of asn1.js using native BigInt)
Author: Fedor Indutny
Latest version: 1.0.0

# ASN1.js

ASN.1 DER Encoder/Decoder and DSL for Node.js with no dependencies

## Acknowledgement

This is a fork of [@indutny's](https://github.com/indutny) `asn.js` library with the following
changes made:

- all `.int()` returns are native `BigInt` values
- lint using [`standard`](https://github.com/standard/standard)

## Example

Define model:

```js
const asn = require('@panva/asn1.js')

const Human = asn.define('Human', function () {
  this.seq().obj(
    this.key('firstName').octstr(),
    this.key('lastName').octstr(),
    this.key('age').int(),
    this.key('gender').enum({ 0: 'male', 1: 'female' }),
    this.key('bio').seqof(Bio)
  )
})

const Bio = asn.define('Bio', function () {
  this.seq().obj(
    this.key('time').gentime(),
    this.key('description').octstr()
  )
})
```

Encode data:

```js
const output = Human.encode({
  firstName: 'Thomas',
  lastName: 'Anderson',
  age: 28,
  gender: 'male',
  bio: [
    {
      time: new Date('31 March 1999').getTime(),
      description: 'freedom of mind'
    }
  ]
}, 'der')
```

Decode data:

```js
const human = Human.decode(output, 'der')
console.log(human)
/*
{ firstName: <Buffer 54 68 6f 6d 61 73>,
  lastName: <Buffer 41 6e 64 65 72 73 6f 6e>,
  age: 28n,
  gender: 'male',
  bio:
   [ { time: 922820400000,
       description: <Buffer 66 72 65 65 64 6f 6d 20 6f 66 20 6d 69 6e 64> } ] }
*/
```

### Partial decode

Its possible to parse data without stopping on first error. In order to do it,
you should call:

```js
const human = Human.decode(output, 'der', { partial: true })
console.log(human)
/*
{ result: { ... },
  errors: [ ... ] }
*/
```
npm package: @panva/hkdf
Description: HKDF with no dependencies using runtime's native crypto
Author: Filip Skokan
Latest version: 1.2.1

# hkdf

> HKDF with no dependencies using runtime's native crypto

HKDF is a simple key derivation function defined in [RFC 5869][].

## Documentation

▸ **hkdf**(`digest`, `ikm`, `salt`, `info`, `keylen`): `Promise`<`Uint8Array`\>

The given `ikm`, `salt` and `info` are used with the `digest` to derive a key of `keylen` bytes.

### Parameters

| Name | Type | Description |
| :------ | :------ | :------ |
| `digest` | ``"sha256"`` \| ``"sha384"`` \| ``"sha512"`` \| ``"sha1"`` | The digest algorithm to use. |
| `ikm` | `Uint8Array` \| `string` | The input keying material. It must be at least one byte in length. |
| `salt` | `Uint8Array` \| `string` | The salt value. Must be provided but can be zero-length. |
| `info` | `Uint8Array` \| `string` | Additional info value. Must be provided but can be zero-length, and cannot be more than 1024 bytes. |
| `keylen` | `number` | The length in bytes of the key to generate. Must be greater than 0 and no more than 255 times the digest size. |

### Returns

`Promise`<`Uint8Array`\>

### Example

**`example`** ESM import
```js
import hkdf from '@panva/hkdf'
```

**`example`** CJS import
```js
const { hkdf } = require('@panva/hkdf')
```

**`example`** Deno import
```js
import hkdf from 'https://deno.land/x/hkdf/index.ts'
```

**`example`** Usage
```js
const derivedKey = await hkdf(
  'sha256',
  'key',
  'salt',
  'info',
  64
)
```

## Supported Runtimes

The supported JavaScript runtimes include ones that

- are reasonably up to date ECMAScript
- support the utilized Web API globals and standard built-in objects
- These are
  - _(This is not an exhaustive list)_
  - Browsers
  - Cloudflare Workers
  - Deno
  - Electron
  - Netlify Edge Functions
  - Next.js Middlewares
  - Node.js
  - Vercel Edge Functions

[RFC 5869]: https://www.rfc-editor.org/rfc/rfc5869.html
npm package: @panva/jose
Description: JSON Web Almost Everything - JWA, JWS, JWE, JWK, JWT, JWKS for Node.js with minimal dependencies
Author: Filip Skokan
Latest version: 1.9.3
Deprecated: @panva/jose has moved. It is now called just "jose", no further updates will be made under the @panva/jose package name.

ERROR: No README data found!
npm package: @panva/oauth4webapi
Description: OAuth 2 / OpenID Connect for Web Platform API JavaScript runtimes
Author: Filip Skokan
Latest version: 1.2.1
Deprecated: `@panva/oauth4webapi` on npm has moved. It is now called just `oauth4webapi`, no further updates will be made under the `@panva/oauth4webapi` package name.

# OAuth 2 / OpenID Connect for Web Platform API JavaScript runtimes

> `@panva/oauth4webapi` on npm has moved. It is now called just `oauth4webapi`, no further updates will be made under the `@panva/oauth4webapi` package name.
npm package: @panviz/actionman
Description: Actions manager
Latest version: 0.0.1

[![Build Status](https://travis-ci.org/panviz/actionman.svg?branch=master)](https://travis-ci.org/panviz/actionman)

# Panviz Actionman

Arbitrary implementation of [Command design pattern](https://en.wikipedia.org/wiki/Command_pattern) for cross-modules communication with logging.
This enables undo / redo and actions log functionality.

## [Live demo](http://daviste.com/demo/panviz-actionman)

## Functionality
+ action panel button click - fire action
+ enable / disable action
+ action panel toggle button
+ multiple components subscribe to action
+ some components subscribe / some not
+ granular update (providing component ids while firing an action)
+ action log
+ undo / redo
- ADD TO DEMO: evaluate if the action can be executed

### TODO
- multiple steps undo / redo
- queue of actions
- Sequences of Command objects can be assembled into composite (or macro) commands.

### Consideration on implementation
- Any action should have "id" differentiation?
  in terms of "check at a dinner" example:
    specifying id for the action is telling the Waiter, that Customer want a specific person to cook for him, while this person may or may not be available today or even be a Cook in this restaurant.
  - first param of action.apply is always ids array
  - How to fire an action for all ids?
    - pass 'all'
    - do not specify any
- Does actionman is required / able to keep track of all actions?
  - YES, Actionman is by it's name a manager of actions
- How to undo / redo?
  - Should Undo / Redo be actions too?
    - No, because it is not specific to particular registrar
  - actionman.undo()
    - the way to trigger undo of the last action
  - concreteAction.undo()
    - actual way to undo
+ Should Actionman be a singleton
  - Pros
    - no need to pass the reference to actionman around to each consumer
  - Cons
    - there will be no ability to create multiple instances of application on the same page for them to track their actions independently
  
+ Should Action be a singleton?
  - Pros
    - same as for actionman
  - Cons
    - same as for actionman
    - if not a singleton, consumer needs to ask actionman for an action
npm package: @panviz/layout
Description: Layouts
Latest version: 0.0.1

![[](https://travis-ci.org/panviz/layout.svg?branch=master)](https://travis-ci.org/panviz/layout)

# Panviz Layout
Collection of algorithms for coordinates computation in various layouts with no assumption on actual items positioning mechanism.

## [Live demo](http://daviste.com/demo/panviz-layout)

## Layouts
- Grid - defined by width or height
- Table - defined by number of columns or rows
- List - table with one column
- Radial (circular) - defined by radius
- Force - defined by distance between items

## Roadmap
- Set min / max for layout controls
- Masonry option (for each layout)
- consider individual item size during placement
- Presets http://www.dubberly.com/concept-maps/3x4grid.html

### Add layouts:
- Random
- ? Timeline (based on list)
npm package: @panviz/uuid62
Description: Base62 non-sequential url-safe UUID generator (RFC4122)
Author: Dario Marcelino
Latest version: 0.0.1

[![npm version](https://badge.fury.io/js/uuid-base62.svg)](http://badge.fury.io/js/uuid-base62)
[![Build Status](https://travis-ci.org/dmarcelino/uuid-base62.svg?branch=master)](https://travis-ci.org/dmarcelino/uuid-base62)
[![Dependency Status](https://david-dm.org/dmarcelino/uuid-base62.svg)](https://david-dm.org/dmarcelino/uuid-base62)

# uuid-base62
Base62 non-sequential url-friendly UUID generator (RFC4122)

## Overview

uuid-base62 makes it easy to generate short base62 (or any other base) UUIDs. The unencoded UUIDs are generated by [uuid](https://github.com/kelektiv/node-uuid) which follows [RFC4122](http://www.ietf.org/rfc/rfc4122.txt). The encoded UUIDs are alphanumeric [0-9a-zA-Z] and always have a length of 22 chars.

## Instalation
```shell
npm i uuid-base62 -S
```

## Usage
```javascript
var uuidBase62 = require('uuid-base62');

var uuid = uuidBase62.v4();
// -> 2qY9COoAhfMrsH7mCyh86T

// if the original uuid is needed
var originalUuid = uuidBase62.decode(uuid);
// -> 9af099b2-6244-4fc1-b72b-1d69a24481b7

// if an uuid needs to be encoded
var encoded = uuidBase62.encode('8fc60e7c-3b3c-48e9-a6a7-a5fe4f1fbc31');
// -> 2fNwVYePN8WqqDFvVf7XMN
```

That's it. uuid-base62 also supports other bases, example for base64:
```javascript
uuidBase62.customBase = new uuidBase62.baseX("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ-_");
var uuid = uuidBase62.v4();
// -> 31LoSI_BVeQpXtwu_-GEbL
```

For more examples check the [tests](https://github.com/dmarcelino/uuid-base62/blob/master/test/uuid-base62.test.js).

## License
MIT