open-index/open-npm huggingface dataset:
npm package: @peassoft/verror
Description: Extanded JavaScript error
Author: Alexey Gorokhov
Latest version: 1.0.0

# @peassoft/verror

JavaScript error class extended with:

- custom `name` property;
- optional `info` object.


## Installation

```bash
$ npm install @peassoft/verror
```


## Usage example

```javascript
import VError from '@peassoft/verror';

const originalError = new Error('foo');

const err = new VError(
  {
    name: 'MyCustomError,
    cause: originalError,
    info: {
      anyField1: 'bar',
      anyField2: 1,
    },
  },
  'error message',
);
```


## API Reference

### `constructor(opts, message)`

- `opts` - Options bucket:

  - `opts.name: string` - Custom error name.

  - `opts.cause?: Error` - _Optional_. An `Error` object that caused the constructed Error.

  - `opts.info?: Record<string, unknown>` - _Optional_. A bucket for any additional information describing the context of the constructed error.

- `message: string` - Error message.
npm package: @peavy-log/web
Description: Peavy remote logging library for web
Author: Magnus
Latest version: 1.0.3

# Peavy Web/TypeScript Library

## Installation

```bash
npm install @peavy-log/web
```

## Usage

```typescript
import { Peavy, LogLevel } from '@peavy-log/web';

// Initialize
Peavy.init({
  endpoint: 'https://my-endpoint.com',
  logLevel: LogLevel.Info,
  printToConsole: true,
});
```

### Logging

```typescript
// Simple logging
Peavy.t('Trace message'); // Trace
Peavy.d('Debug message'); // Debug
Peavy.i('Info message', {
  extra: 'data',
}); // Info
Peavy.w('Warning message'); // Warning
Peavy.e('Error message'); // Error

// Logging with errors
try {
  // some code
} catch (error) {
  Peavy.e('Operation failed', error);
}

// Advanced logging with custom builder
Peavy.log((builder) => {
  builder.level = LogLevel.Warning;
  builder.message = 'Custom log message';
  builder.json = { customField: 'value' };
});
```

### Events

Track user actions and state changes.

State changes are events that represent a persistent configuration or mode of the application changing.
Examples include changing dark mode/theme/colors or enabling/disabling a feature.

```typescript
import { Peavy } from '@peavy-log/web';

// Track a user action
Peavy.action('user', 'login', 1200, EventResult.Success);
Peavy.action('qr', 'open');

// Track state events
Peavy.state('<category>', '<name>', '<value>');
Peavy.state('app', 'persistence', 'indexeddb');
```

### Metadata

Add persistent metadata to all logs. This persists across sessions (using localstorage).

This should be used sparingly, and only for data that is relevant for all logs and events,
and which is not available or inferrable elsewhere.

Versions are automatically managed, so need not be added. The same goes for environment and global app info.

```typescript
// Set metadata
Peavy.setMeta({
  userId: '12345',
});

// Clear metadata
Peavy.clearMeta();
```

## Integrations

### Axios

If you're using axios, you can use the Peavy's interceptors to automatically log requests and responses, plus add tracing headers the requests.

```typescript
import axios from 'axios';
import {
  peavyRequestInterceptor,
  peavyResponseInterceptor,
  peavyErrorInterceptor,
} from '@peavy-log/web/integrations/axios';

axios.interceptors.request.use(peavyRequestInterceptor);
axios.interceptors.response.use(peavyResponseInterceptor, peavyErrorInterceptor);
```
npm package: @pebbledash/core
Description: Headless dashboard core: tiles, constraints, history
Author: pebbledash Contributors
Latest version: 1.0.2

# @pebbledash/core

Headless dashboard engine (no DOM) with perfect tiling.

## Install

Workspace usage in this monorepo. For external projects:

```bash
pnpm add @pebbledash/core
```

## Quick start

```ts
import { DashboardModel } from '@pebbledash/core';

const model = new DashboardModel({ minTile: { width: 5, height: 5 } });
await model.initialize();
const first = model.getState().toArray()[0];
await model.splitTile(first.id, { orientation: 'vertical', ratio: 0.5 });
```

## Extending constraints

```ts
import { GraphRegistry, ConditionNode } from '@pebbledash/core';

// Add a custom condition
const PositiveRatio = new ConditionNode(
  'PositiveRatio',
  (ctx) => (ctx as any).params.ratio > 0,
  () => ({ code: 'NonPositiveRatio', message: 'ratio must be > 0' }),
);

const constraints = new GraphRegistry();
// ... register graphs using PositiveRatio
```

## Deletion semantics

- Strategy-driven, hole-free compaction via seam collapse (vertical or horizontal).
- Pre-checks: `TileExists`, `NotLocked`, `NotOnlyTile`, group policy, full-span coverage, unlocked neighbors.
- Validation: `BoundsValid` + `CoverageTight` ensure no overlaps and no gaps.
- Group policy: fill from within the same group when group size > 1; when deleting the last member, the group is removed and cross-group fill is allowed.

Optional config:

```ts
const model = new DashboardModel({
  // epsilon used in geometry checks and CoverageTight
  epsilon: 1e-6,
  // Strategy can be extended/overridden via StrategyRegistry
});
```

## Persistence

```ts
import { PersistenceManager, MemoryAdapter } from '@pebbledash/core';
const pm = new PersistenceManager(new MemoryAdapter());
await pm.save('layout-1', model.createSnapshot());
const snapshot = await pm.load('layout-1');
```
npm package: @pebblehouse/odin-cli
Description: CLI for Odin — the knowledge backbone for Pebble House
Latest version: 0.10.0

# @pebblehouse/odin-cli

CLI for [Odin](https://www.odin.mu) — the knowledge backbone for Pebble House.

## Install

```bash
npm install -g @pebblehouse/odin-cli
```

## Setup

```bash
# Authenticate via browser (Google sign-in)
odin login
```

This opens your browser, completes Google OAuth, and stores credentials locally at `~/.odin/credentials.json`. Tokens auto-refresh — you won't need to re-login for ~6 months.

## Usage

### Pebbles

```bash
odin pebbles list
odin pebbles get <slug>
odin pebbles create <slug> --name "My Project"
odin pebbles update <slug> --status building
```

### Documents

```bash
odin docs list <slug>
odin docs get <slug> <type>
odin docs create <slug> architecture --title "Architecture" --file ./ARCHITECTURE.md
odin docs update <slug> architecture --file ./ARCHITECTURE.md
```

### Decisions

```bash
odin decisions list <slug>
odin decisions log <slug> "Use Hono for API" --rationale "Lightweight, consistent"
```

### Context (Tier 1 Retrieval)

```bash
odin context <slug>              # Last 20 observations
odin context <slug> --limit 50   # Custom limit
```

### Sessions

```bash
odin sessions start <slug>                    # Returns session ID
odin sessions end <session-id> --summary "Completed auth"
```

### Search

```bash
odin search "authentication"                  # Cross-pebble
odin search "RLS policies" --pebble odin      # Scoped
```

### Auth

```bash
odin login    # Browser OAuth
odin logout   # Clear credentials
```

## Output

All commands output JSON to stdout. Errors go to stderr with non-zero exit codes.

## Configuration

| Variable | Default | Description |
|----------|---------|-------------|
| `ODIN_API_URL` | `https://www.odin.mu` | API base URL |
| `ODIN_SUPABASE_URL` | — | Supabase URL (for token refresh) |
| `ODIN_SUPABASE_ANON_KEY` | — | Supabase anon key (for token refresh) |

## License

MIT
npm package: @pebbleio/client-browser
Description: Client for sending events to `pebble.io` from the browser
Latest version: 0.4.2

<p align="center">
  <a aria-label="Pebble logo" href="https://sovereign.co/team" />
    <img src="https://d33wubrfki0l68.cloudfront.net/fc424fbfedeb8bf5be8001e7b68401a42b434302/f25df/assets/images/logos/pebble_v1.0.svg" height="128"/>
  </a>
</p>

<br>

<p align="center">
  Client for sending events to <kbd>pebble.io</kbd> from the <strong>Browser</strong>.
</p>

<p align="center">
  <a aria-label="Sovereign logo" href="https://sovereign.co">
    <img alt="" src="https://img.shields.io/badge/MADE%20BY%20Sovereign-003058.svg?style=for-the-badge">
  </a>
  <a aria-label="NPM Version" href="https://www.npmjs.com/package/@pebbleio/client-browser">
    <img alt="" src="https://img.shields.io/npm/v/@pebbleio/client-browser.svg?style=for-the-badge&labelColor=003058">
  </a>
  <a aria-label="License" href="https://github.com/pebble-io/client-browser/blob/main/LICENSE">
    <img alt="" src="https://img.shields.io/npm/l/@pebbleio/client-browser.svg?style=for-the-badge&labelColor=003058">
  </a>
</p>

<br>

## References

- [Changelog](./CHANGELOG.md)
- [Development Notes](./DEVELOPMENT.md)
npm package: @pebblo/logger
Description: The logger that we use in the pebblo applications
Author: Kyle
Latest version: 0.0.2

<h1 align="center">@pebblo/logger</h1>
<p align="center">The logger that is used in the @pebblo applications</p>
<div align="center">
  <img src="https://awau.moe/8APmHio.png" width="100%" />
</div>

## Installation 
```bash
$ npm install @pebblo/logger
```
## How to use?
```ts
import Logger from '@pebblo/logger';

/*
* TITLE (Something like DATABASE, INFO)
* MESSAGE
* DATE BOOLEAN (Set to false if you don't want to see the date timestamp)
* COLORS ['red', 'blue'] 
* The first parameter is what the title color will be
* The second color parameter will be the message color
*/

Logger('ERROR', 'Oh no something went wrong!', true, ['red']);
```

## LICENSE
- Published under the MIT LICENSE.
## Credits
- Date function was made by my [friend](https://github.com/auguwu)

## Colors
```
blue
cyan
red
green
yellow
darkblue
magenta
white
black
brightblack
brightred
brightgreen
brifghtyellow
brightblue
brightmagenta
brightcyan
brightwhite
default
````
npm package: @pebg/multi-elo
Description: This package implements a multiplayer extension of the popular Elo rating system
Author: Samuel Höra
Latest version: 2.2.2

# multi-elo

<p align="center">
  <a href="https://www.npmjs.com/package/multi-elo"><img src="https://img.shields.io/npm/v/multi-elo"/></a>
  <a href="http://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen.svg"/></a>
</p>

#

This package implements a multiplayer extension of the popular Elo rating system.

- [Installation](#installation)
- [Example Usage](#example-usage)
- [Methodology](#methodology)
  - [Traditional Elo ratings](#traditional-elo-ratings)
  - [Extension to multiplayer](#extension-to-multiplayer)

This Package is based on [djcunningham0s python implementation](https://github.com/djcunningham0/multielo/).
For additional information, see his [blog post](https://towardsdatascience.com/developing-a-generalized-elo-rating-system-for-multiplayer-games-b9b495e87802) on Towards Data Science (or try [this link](https://towardsdatascience.com/developing-a-generalized-elo-rating-system-for-multiplayer-games-b9b495e87802?sk=89615c121aa78c7b502e9dce35ece5e1) if you hit a paywall).

## Installation

The package can be installed from GitHub or npm by using `npm`.

```bash
npm install multi-elo
```

You can install a specific released version of the package using tag names.
For example, to install release v0.0.1 you can use:

```bash
npm install multi-elo@v0.0.1
```

## Example Usage

The following example shows how to calculate updated Elo ratings after a matchup using the default settings in the package.

```typescript
import { MultiElo } from 'multi-elo';

# player with 1200 rating beats a player with 1000 rating
MultiElo.getNewRatings([1200, 1000])
# [1207.68809835,  992.31190165]

# player with 900 rating beats player with 1000 rating
MultiElo.getNewRatings([900, 1000])
# [920.48207999, 979.51792001]

# 3-way matchup
MultiElo.getNewRatings([1200, 900, 1000])
#  [1208.34629612,  910.43382278,  981.21988111]
```

See [`demo.md`](https://github.com/hoersamu/multi-elo/blob/main/demo.md) for a more in-depth tutorial, including details on parameters that can be tuned in the Elo algorithm.

## Methodology

For more Info on the methodology read [djcunningham0s Readme](https://github.com/djcunningham0/multielo/).
npm package: @pebula/attribus
Description: [![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://shlomiassaf.github.io/pebula-node/attribus/docs/getting-started/introduction/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/attribus?color=green&style
Author: Shlomi Assaf
Latest version: 0.0.1

# `@pebula/attribus`

[![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://shlomiassaf.github.io/pebula-node/attribus/docs/getting-started/introduction/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/attribus?color=green&style=for-the-badge)

**AttriBus** (Attribute Driven ServiceBus) is a library that provide the tools to create an attribute driven service bus architecture.
It simplifies how we use and manage service bus through an declarative API that automate message handling & emitter registration:

:::info
**AttriBus** is a wrapper around the [Azure Service Bus JS client library](https://github.com/Azure/azure-sdk-for-js/tree/master/sdk/servicebus/service-bus)
:::

### Message Handling

Handling incoming service bus message is now as easy as handling incoming REST requests.

```typescript
export class ServiceBusController {
  @Queue<MethodDecorator>(({
    name: 'attribus-queue.demo'
  })
  async myQueueEntity(context: SbContext) {
  }
}
```

### Client Emitters

Defining service bus emitters (`Sender`) requires no logic, you can compose a client emitter in seconds:

```typescript
export class ServiceBusEmitClient {

  @QueueEmitter({
    name: 'attribus-queue.demo'
  })
  myQueueEntity: Sender;
}
```

### Easy Setup

The library also helps with service bus entity management through a declarative API for automatic creation
of service bus entities based on the entities we define in the controllers / services in our application.

We call it **provision**.

This allows a **code-first** approach for service bus management and architecture.

### Leverage Advanced Architecture Patterns

By simplifying the work with service bus, **AttriBus** enables the use of more advanced architecture patterns that you
can use to manage the flow of your application.

Using **Observables** you can now implement a **CQRS** or **Event Sourcing** models out of the box.
In addition, **Observables** along with **Interceptors** allow us to use plugins that encapsulate behaviors for us.

For example, the **SbBackoffRetry plugin** wraps incoming service bus messages and handles them when their handler throws.
It will perform a retry to handle them again but with a delay between each try. The delay is not constant and it is based on an algorithm (linear / exponential)
so the effect of periodic stress on you server is reduced.
npm package: @pebula/decorate
Description: Strictly typed decorator management tool for metadata driven libraries / applications.
Author: Shlomi Assaf
Latest version: 1.0.0

## `@pebula/decorate`  

Strictly typed decorator management tool for metadata driven libraries / applications.

[![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/decorate)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/decorate?color=green&style=for-the-badge)  [![GitHub](https://img.shields.io/badge/Source_Code-green?style=for-the-badge&logo=github)](https://github.com/pebula/node/tree/main/libs/decorate)
npm package: @pebula/goosetyped
Description: [![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/goosetyped/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/goosetyped?color=green&style=for-the-badge)  [![GitHub](https://img.sh
Author: Shlomi Assaf
Latest version: 1.0.1

# `@pebula/goosetyped`

[![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/goosetyped/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/goosetyped?color=green&style=for-the-badge)  [![GitHub](https://img.shields.io/badge/Source_Code-green?style=for-the-badge&logo=github)](https://github.com/pebula/node/tree/main/libs/goosetyped)


**GooseTyped** allows you to focus on building your models more clearly. Simplifying most of the domain
specific concepts of mongoose resulting in a modern ORM code which in turn, allows taking advantage of modern JS features and
design patterns.

## One Model One Schema

With **GooseTyped** you no longer need to define a schema and then create a model class from it, everything is streamlined
into one single class.

```ts
import { GtDocument, GtModel } from '@pebula/goosetyped';

@GtDocument()
export class Customer extends GtModel() {
  @GtColumn()
  name: string;

  @GtColumn()
  age: number;
}
```

This is very powerful when working in TypeScript as no sorcery is required to properly export your model class types.

## Not an ORM

**GooseTyped** is not an ORM by itself and **does not** provide additional functionality on-top of mongoose.  
It is a wrapper around mongoose which provide modern tools to define and and configure the DB schema which is
more adapted to TypeScript and modern ORM libraries.
npm package: @pebula/nesbus
Description: [![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/nesbus/docs/getting-started/introduction/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/nesbus?color=green&style=for-the-badge) 
Author: Shlomi Assaf
Latest version: 7.10.0

# `@pebula/nesbus`

[![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/nesbus/docs/getting-started/introduction/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/nesbus?color=green&style=for-the-badge)  [![GitHub](https://img.shields.io/badge/Source_Code-green?style=for-the-badge&logo=github)](https://github.com/pebula/node/tree/main/libs/nesbus)

**NesBus** (Nest / Service Bus) is a microservice extension for **NestJS** that adds support for Azure Service Bus within **NestJS** in a
simple and intuitive way.

It simplifies how we use and manage service bus through an declarative API that automate message handling & emitter registration:

### Message Handling

Handling incoming service bus message is now as easy as handling incoming REST requests.

```typescript
@Controller()
export class ServiceBusController {
  @Queue<MethodDecorator>(({
    name: 'nesbus-queue.demo'
  })
  async myQueueEntity(@Ctx() context: SbContext) {
  }
}
```

### Client Emitters

Defining service bus emitters (`Sender`) requires no logic, you can compose a client emitter in seconds:

```typescript
@Injectable()
export class ServiceBusEmitClient {

  @QueueEmitter({
    name: 'nesbus-queue.demo'
  })
  myQueueEntity: Sender;
}
```

### Easy Setup

The library also helps with service bus entity management through a declarative API for automatic creation
of service bus entities based on the entities we define in the controllers / services in our application.

We call it **provision**.

This allows a **code-first** approach for service bus management and architecture.

### Leverage Advanced Architecture Patterns

By simplifying the work with service bus, **Nesbus** enables the use of more advanced architecture patterns that you
can use to manage the flow of your application.

Using **Observables** you can now implement a **CQRS** or **Event Sourcing** models out of the box.
In addition, **Observables** along with **Interceptors** allow us to use plugins that encapsulate behaviors for us.

For example, the **SbBackoffRetry plugin** wraps incoming service bus messages and handles them when their handler throws.
It will perform a retry to handle them again but with a delay between each try. The delay is not constant and it is based on an algorithm (linear / exponential)
so the effect of periodic stress on you server is reduced.
npm package: @pebula/nform
Description: Angular Forms
Author: Shlomi Assaf
Latest version: 0.0.1-alpha.11

![npm (scoped)](https://img.shields.io/npm/v/@pebula/nform?label=nform&style=flat-square)
![npm (scoped)](https://img.shields.io/npm/v/@pebula/nform-material?label=nform-material&style=flat-square)
![CircleCI](https://img.shields.io/circleci/build/github/shlomiassaf/nform/master?style=flat-square&token=abc123def456)
![GitHub](https://img.shields.io/github/license/shlomiassaf/nform?style=flat-square)

# N-FORM

---

For full documentation, walkthroughs and examples - [visit the official site](https://shlomiassaf.github.io/nform)

---

## Quick Start

- [Documentation site](https://shlomiassaf.github.io/nform) with code samples.
- [Starter @ GitHub](https://github.com/shlomiassaf/nform-material-starter)
- [Starter @ StackBlitz](https://stackblitz.com/edit/pebula-nform-starter?file=app%2Fapp.component.ts)

## Setup

```bash
yarn add @pebula/utils @pebula/nform @pebula/nform-material
```
npm package: @pebula/tom
Description: A super-fast, type safe, object serialization, validation and mapping
Author: Shlomi Assaf
Latest version: 1.0.0

## `@pebula/tom`  

A super-fast, type safe, object serialization, validation and mapping

[![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/tom)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/tom?color=green&style=for-the-badge)  [![GitHub](https://img.shields.io/badge/Source_Code-green?style=for-the-badge&logo=github)](https://github.com/pebula/node/tree/main/libs/tom)
npm package: @pebula/touchstone
Description: Metadata-driven benchmarking framework, built on top of [benchmark.js](https://benchmarkjs.com/)
Author: Shlomi Assaf
Latest version: 1.0.2

# `@pebula/touchstone`

Metadata-driven benchmarking framework, built on top of [benchmark.js](https://benchmarkjs.com/)

[![Documentation](https://img.shields.io/badge/Documentation-9cf?style=for-the-badge)](https://pebula.github.io/node/touchstone/docs/getting-started/introduction/)   ![npm (scoped)](https://img.shields.io/npm/v/@pebula/touchstone?color=green&style=for-the-badge)  [![GitHub](https://img.shields.io/badge/Source_Code-green?style=for-the-badge&logo=github)](https://github.com/pebula/node/tree/main/libs/touchstone)
npm package: @pech/chess-core
Description: A fast, type-safe chess library with immutable state and bitboard representation
Author: Eduardo Pech
Latest version: 1.0.3

# chess-core

A fast, type-safe chess library for JavaScript and TypeScript. Immutable state, bitboard representation, and a pure functional API.

**[Documentation](https://eduardopech.github.io/chess-core/)** — visit for guides, examples, and the full API reference.

**[Interactive example](https://eduardopech.github.io/chess-board/guides/example/)** — see chess-core combined with [chess-board](https://github.com/eduardopech/chess-board) for a draggable board with legal moves and position updates.

## Features

- **Bitboard-based** move generation for high performance
- **Immutable positions** -- every move returns a new state
- **Pure functions** -- no hidden state, fully tree-shakeable
- **Type-safe** -- branded types for squares, files, and ranks
- **Perft-tested** -- verified against known node counts

## Install

```bash
npm install @pech/chess-core
# or
bun add @pech/chess-core
```

## Quick Start

```typescript
import { fromFen, getLegalMoves, makeMove, toSan, isCheckmate, STARTING_FEN } from '@pech/chess-core';

const pos = fromFen(STARTING_FEN);
const moves = getLegalMoves(pos);
const newPos = makeMove(pos, moves[0]);

console.log(toSan(pos, moves[0]));   // "e4"
console.log(isCheckmate(newPos));     // false
```

## API

### Position

```typescript
fromFen(fen: string): Position
toFen(pos: Position): string
```

### Move Generation

```typescript
getLegalMoves(pos: Position): Move[]
getPseudoLegalMoves(pos: Position): Move[]
```

### Making Moves

```typescript
makeMove(pos: Position, move: Move): Position
```

### Validation

```typescript
isCheck(pos: Position): boolean
isCheckmate(pos: Position): boolean
isStalemate(pos: Position): boolean
isInsufficientMaterial(pos: Position): boolean
isFiftyMoveRule(pos: Position): boolean
isSquareAttacked(pos: Position, sq: Square, byColor: Color): boolean
```

### Notation

```typescript
toSan(pos: Position, move: Move): string
toUci(move: Move): string
fromUci(pos: Position, uci: string): Move | null
fromSan(pos: Position, san: string): Move | null
```

### Perft

```typescript
perft(pos: Position, depth: number): number
divide(pos: Position, depth: number): DivideResult[]
```

## Development

```bash
bun install          # install dependencies
bun run test         # run tests
bun run test:watch   # run tests in watch mode
bun run build        # build with tsup
bun run typecheck    # type-check without emitting
```

## License

MIT
npm package: @pechuri/sparkles
Description: https://joshwcomeau.com/react/animated-sparkles-in-react/
Author: Praneeth Echuri
Latest version: 1.0.1

# sparkles

https://joshwcomeau.com/react/animated-sparkles-in-react/

This library provides two named exports: the Sparkles React component, and the useRainbow React hook.

`Sparkles` takes a single prop: color. You can either pass a single color or an array of colors. The useRainbow hook is for generating colors for the Sparkles component if you want your sparkles to be multicolored.
npm package: @peckadesign/pd-modal
Description: TypeScript plugin for modal window.
Author: PeckaDesign, s.r.o
Latest version: 2.10.1

# pd-modal

## Quick start
```
$ npm install @peckadesign/pd-modal
```

```typescript
import { PdModal, HTMLContentLoader } from '@peckadesign/pd-modal'

const modal = new PdModal()
modal.registerContentLoader(new HTMLContentLoader())
```

This code will create instance of a modal window. The content itself is loaded using content loaders. This allows you to import only loaders you actually need in your project.

When `HTMLContentLoader` is registered, the modal is automatically binded to link elements with `class="js-modal"` by default. For more in-depth info and complete documentation, please see [example](/example/index.html).