open-index/open-npm huggingface dataset:
npm package: @rasmuswu/rainbow-log
Description: Creates a colouful console log
Author: RasmusWU
Latest version: 2.0.0

# Rainbow-log
This poggers package makes a colourful console log.
It's based. BASED, I TELL YOU!!

## Usage
Install with `npm i @noget/rainbow-log`

```javascript
var rainbowLog = require("@noget/rainbow-log");

rainbowLog("I am i rainbow :o");
```
npm package: @rasmx/blake3
Description: The fastest BLAKE3 implementation for the Web. Rust/WASM powered, SIMD accelerated, Zero-Allocation architecture.
Author: deniis
Latest version: 1.0.1

# @rasmx/blake3 ⚡️

> **The definitive BLAKE3 implementation for WebAssembly.**  
> 600+ MB/s of pure hashing power. Up to 40x faster than pure JS implementations.

[![npm version](https://img.shields.io/npm/v/@rasmx/blake3.svg)](https://www.npmjs.com/package/@rasmx/blake3)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](https://opensource.org/licenses/MIT)

Rasmx is a high-performance cryptographic library written in Rust and compiled to WebAssembly with manual SIMD128 optimizations. It bypasses traditional JS-to-WASM overhead using a **Zero-Copy** architecture.

## 🚀 Performance

| Algorithm | Engine | 10MB Throughput | Speedup |
| :--- | :--- | :--- | :--- |
| **BLAKE3** | **@rasmx/blake3** | **~670 MB/s** | **35x** |
| BLAKE3 | @noble/hashes | ~19 MB/s | 1x |
| SHA256 | WebCrypto (Native) | ~250 MB/s | 0.4x |

*Tested on modern x86_64/ARM64 hardware in Chromium-based browsers.*

## 🛠 Features

- **SIMD Accelerated**: Hand-crafted for WebAssembly SIMD instructions.
- **Zero-Copy Architecture**: Access WASM memory directly to avoid expensive data cloning.
- **Zero-Allocation**: No garbage collection overhead; contexts are managed in a static slab.
- **Synchronous Execution**: Once initialized, all calls are 100% synchronous.
- **Streaming API**: Efficiently process gigabytes of data in chunks.

## 📦 Installation

```bash
pnpm add @rasmx/blake3
```

## 📖 Quick Start

### The "God Mode" (Zero-Copy)
For maximum performance, write your data directly into the WASM buffer.

```typescript
import { init, getBuffer, hashInplace } from '@rasmx/blake3';

await init();

const dataSize = 1024 * 1024; // 1MB
const buffer = getBuffer(dataSize);

// Fill the buffer directly (e.g., from a File or Stream)
// No .set() or extra copies!
for (let i = 0; i < dataSize; i++) {
    buffer[i] = i & 0xff;
}

const result = hashInplace(dataSize);
```

### Simple One-Shot
Standard usage with automatic data copying.

```typescript
import { init, hash } from '@rasmx/blake3';

await init();
const digest = hash(myUint8Array);
```

### Streaming API
Process data without loading it all into memory.

```typescript
import { init, Hasher, getBuffer } from '@rasmx/blake3';

await init();
const hasher = new Hasher();

// Chunk 1
const buf1 = getBuffer(1024);
buf1.set(chunk1);
hasher.update(1024);

// Chunk 2
const buf2 = getBuffer(2048);
buf2.set(chunk2);
hasher.update(2048);

const finalHash = hasher.digest();
```

## 🏗 Architecture

Rasmx uses a "Static Slab Allocation" strategy. It reserves 16 independent hashing contexts in the WASM linear memory at compile-time. This ensures that even with complex streaming, no memory allocation or deallocation occurs during runtime, preventing memory fragmentation and GC pauses.

## License

MIT © Rasmx Team
npm package: @rasmx/blake3-node
Description: High-performance BLAKE3 hashing bindings for Node.js using Rust and SIMD optimizations.
Author: deniis
Latest version: 1.0.1

# @rasmx/blake3-node

> **The fastest BLAKE3 hashing library for Node.js.**
> Powered by Rust, SIMD (AVX-512/NEON), and N-API.

[![npm version](https://img.shields.io/npm/v/@rasmx/blake3-node.svg)](https://www.npmjs.com/package/@rasmx/blake3-node)

## Features

- 🚀 **Extreme Performance**: Outperforms native Node.js `crypto` and other WASM libraries.
- 🧵 **Multi-threaded**: Automatic Rayon parallelism for large inputs.
- ⚡ **Async & Sync**: Non-blocking `async` support for high-throughput servers.
- 🛡 **Type-Safe**: Written in Rust with full TypeScript definitions.
- 📦 **Zero Dependencies**: Statically linked binary, no system requirements.

## Installation

```bash
pnpm add @rasmx/blake3-node
# or
npm install @rasmx/blake3-node
```

## Usage

### Synchronous (Block hashing)

Best for small inputs or CLI tools.

```javascript
import { hash } from '@rasmx/blake3-node';

const buffer = Buffer.from("Hello World");
const digest = hash(buffer);
console.log(digest); // Hex string
```

### Asynchronous (Promise based)

Best for servers (Express, Fastify) to avoid blocking the Event Loop.

```javascript
import { hashAsync } from '@rasmx/blake3-node';
import fs from 'fs/promises';

async function processFile() {
  const data = await fs.readFile('./large-file.iso');
  const digest = await hashAsync(data);
  console.log(digest);
}
```

### Streaming (Class based)

For memory-efficient processing of streams.

```javascript
import { Blake3Hasher } from '@rasmx/blake3-node';

const hasher = new Blake3Hasher();

hasher.update(Buffer.from("Chunk 1"));
hasher.update(Buffer.from("Chunk 2"));

const hex = hasher.digest();       // String
const bin = hasher.digestBinary(); // Buffer
```

## Benchmarks

Running on Ryzen 9 5900X (Single Thread):

| Input Size | Method | Speed |
|------------|--------|-------|
| 100 MB     | Sync   | ~3450 MB/s |
| 100 MB     | Async  | ~1150 MB/s |
| 32 B       | Ops    | ~1,850,000 ops/sec |

## License

MIT
npm package: @rasmx/color
Description: High-performance color manipulation library powered by Rust and OKLCH. Support for APCA, WCAG, Harmony, and Modern Color Spaces.
Author: deniis
Latest version: 1.0.0

# @rasmx/color

Universal color manipulation library powered by Rust and WebAssembly. Optimized for modern perceptual color spaces (OKLCH, OKLAB) and professional accessibility tools (APCA, WCAG).

## Features

- **Perceptual Accuracy**: All manipulations (lighten, saturate, mix) are performed in OKLCH space.
- **Modern Standards**: Full support for OKLCH, OKLAB, LAB, and Display-P3 approximations.
- **Accessibility First**: Built-in WCAG 2.1 contrast and APCA (WCAG 3.0 draft) algorithms.
- **Smart Parsing**: Supports Hex, RGB, HSL, OKLCH, and Named colors.
- **Harmony Generation**: Analogous, Triadic, Tetradic, and Monochromatic palettes.

## Installation

```bash
pnpm add @rasmx/color
```

## Quick Start

```javascript
import init, { Color, colorTools } from '@rasmx/color';

await init();

// Create and manipulate
const color = new Color("oklch(0.6 0.2 180)")
  .lighten(0.1)
  .rotate(30);

console.log(color.toHex());
console.log(color.toRgb());

// Professional Contrast (APCA)
const lc = colorTools.apca("#ffffff", "#000000"); // 106.0
```

## License

MIT
npm package: @rasmx/fuzzy
Description: Blazing fast WASM fuzzy search library powered by Rust and Nucleo matcher. Optimized for performance and high-quality matching.
Author: deniis
Latest version: 1.0.0

# @rasmx/fuzzy

Blazing fast fuzzy search library powered by Rust and WebAssembly. Optimized for performance using the `nucleo` matcher.

## Features

- **High Performance**: Powered by Rust's `nucleo-matcher`.
- **Smart Matching**: Supports smart-case and normalization by default.
- **Highlighting**: Built-in utility to highlight matched characters.
- **Stateful Index**: Efficiently handle large datasets without re-copying strings to WASM memory.
- **Rich Results**: Returns scores and character indices for custom UI rendering.

## Installation

```bash
pnpm add @rasmx/fuzzy
```

## Usage

### Basic Usage

```javascript
import init, { fuzzy } from '@rasmx/fuzzy';

await init();

const list = ["apple", "banana", "apricot", "peach"];
const results = fuzzy.search("ap", list);

results.forEach(res => {
    const text = list[res.idx];
    console.log(fuzzy.highlight(text, res.indices)); 
});
```

### Stateful Index (Large Datasets)

```javascript
import init, { FuzzyIndex } from '@rasmx/fuzzy';

await init();

const index = new FuzzyIndex();
index.addBulk(["huge", "list", "of", "strings", "..."]);

const results = index.search("str");
```

## API Reference

### `fuzzy`
- `search(query, list, limit?)`: Returns `SearchResult[]`.
- `highlight(text, indices, prefix?, suffix?)`: Returns `string`.

### `FuzzyIndex`
- `add(text)`: Adds a single string to the index.
- `addBulk(list)`: Adds an array of strings.
- `search(query, limit?)`: Performs a search on the indexed data.
- `clear()`: Clears the internal storage.
- `free()`: Manually release WASM memory.

### `SearchResult`
- `idx`: Index in the original array.
- `score`: Match score (higher is better).
- `indices`: Array of character positions that matched the query.

## License

MIT
npm package: @rasmx/hash
Description: Blazing fast WASM hashing library powered by Rust. Support for SHA2, SHA3, Keccak, XXHash, and MD5 with streaming support.
Author: deniis
Latest version: 1.0.2

# @rasmx/hash 🚀

[![NPM Version](https://img.shields.io/npm/v/@rasmx/hash.svg)](https://www.npmjs.com/package/@rasmx/hash)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Bundle Size](https://img.shields.io/bundlephobia/minzip/@rasmx/hash)](https://bundlephobia.com/package/@rasmx/hash)

**@rasmx/hash** is a high-performance, universal hashing library for JavaScript and TypeScript, powered by **WebAssembly** and **Rust**.

## Why @rasmx/hash?

- **Blazing Fast**: Up to 10-20x faster than pure JS implementations (like crypto-js).
- **Streaming Ready**: Hash gigabytes of data with zero-copy using browser `ReadableStream`.
- **All-in-One**: One tiny package replaces dozens of single-algorithm libraries.
- **Modern**: Full support for `SharedArrayBuffer` and ES Modules.

## Supported Algorithms

| Family | Variants |
| :--- | :--- |
| **SHA2** | 224, 256, 384, 512, 512/224, 512/256 |
| **SHA3** | 224, 256, 384, 512 |
| **Keccak** | 224, 256, 384, 512 |
| **XXHash** | 32, 64, 3-64, 3-128 (with Seed support) |
| **Other** | MD5, HMAC-SHA256, HMAC-SHA512, SHAKE128/256 |

## Quick Start

```javascript
import { hash } from '@rasmx/hash';

// Simple usage
const hex = await hash.sha2.v256("hello world");

// Streaming large files (Browser)
const result = await hash.stream(file.stream(), new IncrementalSha256());
```
npm package: @rasmx/uid
Description: Blazing fast WASM ID generation library powered by Rust. Support for UUID (v1-v7), ULID, NanoID, and Base62 shortening.
Author: deniis
Latest version: 1.0.1

# @rasmx/uid

Blazing fast ID generation library powered by Rust and WebAssembly. Optimized for performance and modern standards.

## Features

- **UUID**: Support for versions 1, 3, 4, 5, 6, and 7.
- **ULID**: Lexicographically sortable identifiers with millisecond precision.
- **NanoID**: Secure, URL-friendly unique identifiers with custom alphabet support.
- **Short IDs**: Built-in Base62 encoding/decoding to shorten your UUIDs.
- **Metadata**: Extract timestamps directly from UUID v7 and ULID.
- **Bulk Generation**: Highly optimized vector-based bulk generation for UUID v7.

## Installation

```bash
pnpm add @rasmx/uid
```

## Usage

### Basic Usage

```javascript
import init, { uuid, ulid, nanoid } from '@rasmx/uid';

// Initialize the WASM module
await init();

// Generate IDs
const idV4 = await uuid.v4();
const idV7 = await uuid.v7();
const myUlid = await ulid.generate();
const myNanoId = await nanoid(21);
```

### Advanced Features

```javascript
// Bulk generation (UUID v7)
const ids = await uuid.bulk(1000);

// Extract timestamp from ID
const date = await uuid.getTimestamp(idV7);
console.log(date.toISOString());

// Shorten UUID (Base62)
const short = await uuid.toShort(idV4);
const original = await uuid.fromShort(short);

// Deterministic UUIDs
const namespace = "6ba7b810-9dad-11d1-80b4-00c04fd430c8";
const idV5 = await uuid.v5(namespace, "example");
```

## API Reference

### `uuid`
- `v1(), v4(), v6(), v7()`: Returns `Promise<string>`
- `v3(ns, name), v5(ns, name)`: Returns `Promise<string>`
- `bulk(amount)`: Returns `Promise<string[]>`
- `isValid(str)`: Returns `Promise<boolean>`
- `toShort(uuid)`: Converts UUID to Base62 string.
- `fromShort(shortId)`: Converts Base62 string back to UUID.
- `getTimestamp(uuid)`: Extracts Date from v7.

### `ulid`
- `generate()`: Returns `Promise<string>`
- `fromTime(ms)`: Generates ULID for specific timestamp.
- `getTimestamp(ulid)`: Extracts Date from ULID.

### `nanoid`
- `nanoid(size?, alphabet?)`: Returns `Promise<string>`

## License

MIT
npm package: @rasoul678/ckeditor5-custom-balloon-block
Description: The balloon editor build of CKEditor 5 with a block toolbar
Author: Raaivan
Latest version: 2.0.0

# CKEditor 5 custom balloon block editor build

## Quick start

First, install the build from npm:

```bash
npm install --save @rasoul678/ckeditor5-custom-balloon-block
```

And use it in your react app:

```js
import { CKEditor } from "@ckeditor/ckeditor5-react";
import BalloonBlockEditor from "@rasoul678/ckeditor5-custom-balloon-block";

const TestView = () => {
	const [data, setData] = useState("<p>Hello from CKEditor 5!</p>");

	useEffect(() => {
		console.log(data);
	}, [data]);

	return (
		<div>
			<h2>Using CKEditor 5 build in React</h2>
			<CKEditor
				editor={BalloonBlockEditor}
				data={data}
				onReady={(editor) => {
					console.log("Editor is ready to use!", editor);
				}}
				onChange={(event, editor) => {
					const data = editor.getData();
					setData(data);
					console.log({ event, editor, data });
				}}
				onBlur={(event, editor) => {
					console.log("Blur.", editor);
				}}
				onFocus={(event, editor) => {
					console.log("Focus.", editor);
				}}
			/>
		</div>
	);
};

export default TestView;
```
npm package: @rasoul_rezaiyan/bondad-hub-client
Description: bondad-hub-client React component
Latest version: 1.1.9

# bondad-hub-client

[![Travis][build-badge]][build]
[![npm package][npm-badge]][npm]
[![Coveralls][coveralls-badge]][coveralls]

Describe bondad-hub-client here.

[build-badge]: https://img.shields.io/travis/user/repo/master.png?style=flat-square
[build]: https://travis-ci.org/user/repo

[npm-badge]: https://img.shields.io/npm/v/npm-package.png?style=flat-square
[npm]: https://www.npmjs.org/package/npm-package

[coveralls-badge]: https://img.shields.io/coveralls/user/repo/master.png?style=flat-square
[coveralls]: https://coveralls.io/github/user/repo
npm package: @raspo/recharts
Description: React charts
Author: recharts group
Latest version: 0.16.2

# Recharts

[![Build Status](https://travis-ci.org/recharts/recharts.svg)](https://travis-ci.org/recharts/recharts)
[![Coverage Status](https://coveralls.io/repos/recharts/recharts/badge.svg?branch=master&service=github)](https://coveralls.io/github/recharts/recharts?branch=master)
[![npm version](https://badge.fury.io/js/recharts.svg)](http://badge.fury.io/js/recharts)
[![npm downloads](https://img.shields.io/npm/dm/recharts.svg?style=flat-square)](https://www.npmjs.com/package/recharts)
[![Gitter](https://badges.gitter.im/recharts/recharts.svg)](https://gitter.im/recharts/recharts?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)

## Intro

Recharts is a **Redefined** chart library built with [React](https://facebook.github.io/react/) and [D3](http://d3js.org).

The main purpose of this library is to help you to write charts in React applications without any pain. Main principles of Recharts are:

1. **Simply** deploy with React components
1. **Native** SVG support, lightweight depending only on some D3 submodules
1. **Declarative** components, components of charts are purely presentational

## Examples

```jsx
<LineChart
  width={400}
  height={400}
  data={data}
  margin={{ top: 5, right: 20, left: 10, bottom: 5 }}
>
  <XAxis dataKey="name" />
  <Tooltip />
  <CartesianGrid stroke="#f5f5f5" />
  <Line type="monotone" dataKey="uv" stroke="#ff7300" yAxisId={0} />
  <Line type="monotone" dataKey="pv" stroke="#387908" yAxisId={1} />
</LineChart>
```

All the components of Recharts are clearly separated. The lineChart is composed of x axis, tooltip, grid, and line items, and each of them is an independent React Component. The clear separation and composition of components is one of the principle Recharts follows.

## Module Formats

- [babel-plugin-recharts](https://github.com/recharts/babel-plugin-recharts) A simple transform to cherry-pick Recharts modules so you don’t have to.

## Contribution

We'd love :heart: to hear what you think we should build. Please create an issue to write your usage or ideas.

We are looking for like-minded people who share the same idea about Recharts. The goal of this project is create a more flexible charting library for the  React community.

## License

[MIT](http://opensource.org/licenses/MIT)

Copyright (c) 2015-2016 Recharts Group
npm package: @rassweiler/kawasaki-as-parser
Description: Kawasaki backup parser
Author: Kyle Rassweiler
Latest version: 3.0.0

# kawasaki-as-parser

<div align="center">

[![Build Status][github-actions-status]][github-actions-url]
[![Github Tag][github-tag-image]][github-tag-url]
[![StackOverflow][stackoverflow-img]][stackoverflow-url]
[![GitHub license][liscense-tag]][liscense-url]
[![npm version][npm-version-tag]][npm-version]

Node module for parsing kawasaki as backup files.

</div>

#
## Usage

### NPM

```bash
$ npm install @rassweiler/kawasaki-as-parser
```

### Yarn

```bash
$ yarn add @rassweiler/kawasaki-as-parser
```

### Importing

```javascript
import KawasakiParser from "@rassweiler/kawasaki-as-parser";
```

### Getting Data

The module's functions can be called independently (All calls return promises):

```javascript
let info = await KawasakiParser.getRobotInformationObject(
	utf8StringArray,
	robotNumber
);
```

Or the `getControllerObject()` function can be called and will return an object containing all of the robot information:

```javascript
let controller = await KawasakiParser.getControllerObject(utf8StringFromAsFile);
```

#
## Typescript types

Currently investigating how to do this.

#
## Milestones

-  [x] Parse comments
-  [ ] Parse Robot Programs
-  [x] Parse Controller Programs
-  [ ] Parse Robot BCD Info
-  [ ] Parse AS reals
-  [ ] Parse AS trans
-  [ ] Parse AS joints
-  [ ] Parse AS strings
-  [ ] Parse Spot Weld Info
-  [ ] Parse MIG Weld Info

#
## Development

```bash
$ git clone https://github.com/rassweiler/kawasaki-as-parser.git
```
change to the desired branch and install the dependencies using yarn:
```bash
$ yarn
```

For convenience install the suggested vscode addons.

Before commiting run:

```bash
yarn test
```

[github-actions-status]: https://github.com/rassweiler/kawasaki-as-parser/workflows/Test/badge.svg
[github-actions-url]: https://github.com/rassweiler/kawasaki-as-parser/actions
[github-tag-image]: https://img.shields.io/github/v/tag/rassweiler/kawasaki-as-parser?label=version
[github-tag-url]: https://github.com/rassweiler/kawasaki-as-parser/releases/latest
[stackoverflow-img]: https://img.shields.io/badge/stackoverflow-kawasaki__as__parser-blue.svg
[stackoverflow-url]: https://stackoverflow.com/questions/tagged/kawasaki-as-parser
[liscense-url]: https://github.com/rassweiler/kawasaki-as-parser/blob/master/LICENSE
[liscense-tag]: https://img.shields.io/badge/license-MIT-blue.svg
[npm-version-tag]: https://img.shields.io/npm/v/@rassweiler/kawasaki-as-parser.svg?style=flat
[npm-version]: https://www.npmjs.com/package/@rassweiler/kawasaki-as-parser
npm package: @rassyabr/ytdl
Description: YouTubdl the powerful one uses ytdl core
Author: Ramm
Latest version: 1.6.0

# YouTube Downloader 

## Installation
npm:
```bash
$ npm install @rassyabr/ytdl
```
yarn:
```bash
$ yarn add @rassyabr/ytdl
```

## Simple to Use
## CommonJs (CJS) syntax
```js
const { ytmp3, ytmp4 } = require('@rassyabr/ytdl');
```
## ECMAScript Modules (ESM) syntax
```ts
import { ytmp3, ytmp4 } from '@rassyabr/ytdl';
```

## Example 

var url = `https://youtube.com/watch?v=60ItHLz5WEA`

## With audio

return ytmp3(url)

## With video

return ytmp3(url)

```
npm package: @rasta-alex/hex2dec
Description: Easy convert hexadecimal to decimal.
Author: rasta-alex
Latest version: 1.0.5

# Hex2Dec 

Easy convert hexadecimal to decimal.

## Install

With npm:

```
npm i @rasta-alex/hex2dec
```
## Usage  

```javascript
const hex2dec = require('@rasta-alex/hex2dec');

const dec = hex2dec('fa'); // 250
```

## License

MIT
npm package: @rasta-alex/readdir
Description: Reading files in folder by size, name, date
Author: RastaAlex
Latest version: 1.0.25

# Readify 

Reading and sorting files in directory. Placing them in a table by values.

## Install

With npm:

```
npm i @rasta-alex/readdir
```
## Examples  

https://raw.githubusercontent.com/RastaAlex/readdir/master/table.png

## License

MIT
npm package: @rastalextremo/platzom
Description: Lenguaje Platzi
Author: Alexander Velasquez
Latest version: 0.1.0

# Platzom
Descripcion de Platzom

## Instalación

```
npm install platzom
```

## Uso
```
import platzom from 'platzom'

platzom("Nombre")
```

## Creditos 

[Alexander Velasquez](http://www.instagram.com/rastalextremo)

## Licencia

[MIT](https://opensource.org/licenses/MIT)
npm package: @rastaxarm/next-shield
Description: The shield that every Next.js project needs with the addition of callback url added to the login endpoint
Author: Jorge Acero
Latest version: 0.1.0-development

<p align="center">
  <img alt="Gatsby GastbyFire" src="./images/nextshield.png" width="300" />
</p>
<h1 align="center">
  NextShield
</h1>

😉 The shield that every Next.js app needs.

## Motivation

After creating a lot of apps with the same boilerplate code for authentication & authorization I realized that I hate dealing with it, so I create this package to never face the same frustrating situation again.

## Philosophy

- Never deal with auth code again.
- Never hardcode a redirect, let your state handle it for you.
- Easy To Use.

## Features

- No Flashy Content.
- RBAC.
- Completely Agnostic.

## Documentation

You can find the documentation at the [official website](https://imjulianeral.github.io/next-shield/).

<!-- ## Examples

[Firebase Example](https://github.com/imjulianeral/next-shield/tree/main/example/ts-fire-example) -->