open-index/open-npm huggingface dataset:
npm package: @kawacrepe/badwords
Description: Blazing fast javascript badwords filter
Author: Vincent Dhennin
Latest version: 1.1.0

# badwords
Javascript filter for badwords. Work in browser & node.
Open for contribution. You can text me on discord Kawacrepe#8492 for any questions.

## Installation

``` npm i @kawacrepe/badwords ```

## Testing

``` npm test ```

## Usage

```javascript
const Filter = require('@kawacrepe/badwords');
const filter = new Filter();

console.log(filter.clean("Don't be an asshole"));
// 'Don't be an ******
```

```javascript
const Filter = require('@kawacrepe/badwords');
const filter = new Filter();

console.log(filter.doesContainBadwords("Don't be an asshole"));
// [true, 'asshole']
```


```javascript
const Filter = require('@kawacrepe/badwords');
const filter = new Filter({list: ['test', 'github'], placeHolder: 'x'});

console.log(filter.clean('Github is really helpfull, asshole'));
// xxxxxx is really helpfull, asshole
```
npm package: @kawaiilab/sagiri
Description: 🔑 En/decrypt images in a kawaii way
Author: Lyn Chen
Latest version: 1.0.4

<p align="center">
  <img src="https://raw.githubusercontent.com/kawaiilab/sagiri/master/example/01-input.png">
</p>

<p align="center">🔑 En/decrypt images in a kawaii way</p>

<p align="center">
<a href="https://lyn.moe"><img alt="Author" src="https://img.shields.io/badge/Author-Lyn-blue.svg?style=for-the-badge"/></a>
<a href="https://www.npmjs.com/package/@kawaiilab/sagiri"><img alt="Version" src="https://img.shields.io/npm/v/@kawaiilab/sagiri.svg?style=for-the-badge"/></a>
<img alt="License" src="https://img.shields.io/github/license/kawaiilab/sagiri.svg?style=for-the-badge"/>
</p>

***

### Installation

```bash
npm install @kawaiilab/sagiri
```

### Usage

En/decrypt a single image

```node
const ctx = canvas.getContext('2d')

const img = await loadImage(imageData)
ctx.drawImage(img, 0, 0)
imgData = ctx.getImageData(0, 0, width, height)

sagiri.encrypt(imgData, ctx, key)
// sagiri.decrypt(imgData, ctx, key)

const out = fs.createWriteStream(__dirname + '/output.png')
const stream = canvas.createPNGStream()
stream.pipe(out)
out.on('finish', () =>  console.log('Finished.'))
```

#### API

```node
sagiri.encrypt(imgData: ImageData, ctx: CanvasRenderingContext2D, key: String)
```

### Performance

```
Encrypt ./example/01-input.png (1920 × 1080)
Max: 539ms
Avg: 528ms
Min: 501ms

Decrypt: ./example/02-input.png (1920 × 1080)
Max: 464ms
Avg: 468ms
Min: 475ms
```

### Examples

Have look at `./example` folder

### Related

[kawaiilab/sagiri-cli](https://github.com/kawaiilab/sagiri-cli)

[kawaiilab/sagiri-web](https://github.com/kawaiilab/sagiri-web)

### Credit

[Tharsanan1/ImageEncryptionWeb](https://github.com/Tharsanan1/ImageEncryptionWeb)

[Illustration: エロマンガ先生!!!](https://www.pixiv.net/artworks/62494753)

### Name

[Sagiri Izumi](https://myanimelist.net/character/100993/Sagiri_Izumi) from [Eromanga-sensei](https://myanimelist.net/anime/32901/Eromanga-sensei?q=Eromanga-sensei&cat=anime)

### LICENSE

MIT
npm package: @kawaiininja/ui
Description: A modern React component library with 45+ premium components for building beautiful web applications
Author: Tristan
Latest version: 1.0.9

# @kawaiininja/ui

A premium React UI component library for building beautiful web applications.

## Component Structure

```
ui/
├── dist/                # Compiled output
└── src/
    └── components/
        └── section/     # Section layout components
            ├── Section.tsx
            ├── SectionHeader.tsx
            └── SectionLabel.tsx
```

## Installation

```bash
npm install @kawaiininja/ui
```

## Usage

```tsx
import { Section, SectionHeader, SectionLabel } from "@kawaiininja/ui";

function MyPage() {
  return (
    <Section space="lg">
      <SectionHeader title="My Section" subtitle="This is a subtitle" />
      <SectionLabel>Label</SectionLabel>
      <div>Content goes here...</div>
    </Section>
  );
}
```

## Features

- **TypeScript Support**: Fully typed components.
- **Modern Design**: Built for premium user interfaces.
- **Flexible**: customizable props and styling.

## Scripts

- `npm run build`: Build the package (TypeScript compilation).
- `npm publish`: Publish to npm (use the provided `publish-ui-*.bat` scripts in the root).
npm package: @kawaiioverflow/arm
Description: A JSON-based database to relation mapping Anime ID's between MAL, Annict, AniList and Syobocal
Author: P-Chan
Latest version: 0.234.0

![](./og-image.png)

# arm

@kawaiioverflow/arm is a JSON-based database to relational mapping Anime ID's between MAL, Annict, AniList and Syobocal.

## Install

```sh
npm i @kawaiioverflow/arm
```

or

```sh
yarn add @kawaiioverflow/arm
```

## Usage

```ts
import { arm } from '@kawaiioverflow/arm'

console.log(arm)
/*
[
  {
    "mal_id": 5114,
    "anilist_id": 5114,
    "annict_id": 1745,
    "syobocal_tid": 1575
  },
  ...
]
*/
```

## Database

### Return values

Return an array of `Anime` type.

```ts
type Anime = {
  mal_id?: number
  annict_id?: number
  anilist_id?: number
  syobocal_tid?: number
}
```

### Statistics

<!-- start statistics -->

The database has **36035** anime, it consists of data from several services.

| Service         | Anime       |
| :-------------- | :---------- |
| MyAnimeList     | 29896 anime |
| AniList         | 22194 anime |
| Annict          | 16851 anime |
| Syoboi Calendar | 6544 anime  |

<!-- end statistics -->

### Release cycle

Once a week, it will be delivered via npm.

---

<small>Inspired by <a href="https://github.com/manami-project/anime-offline-database">manami-project/anime-offline-database</a>.</small>
npm package: @kawaiwang/button
Description: A modern, accessible React Button component library with multiple variants, sizes, and states.
Author: kawaiwang
Latest version: 1.0.0

# @claw-ui/button

一个现代化、可访问的 React Button 组件库，支持多种变体、尺寸和交互状态。

## ✨ 特性

- 🎨 **6 种变体**: Primary、Secondary、Outline、Ghost、Danger、Link
- 📐 **5 种尺寸**: xs、sm、md、lg、xl
- 🔲 **4 种形状**: default、round、circle、square
- ♿ **无障碍**: 完整的 ARIA 支持和键盘导航
- 📦 **轻量**: 零运行时依赖，CSS 独立打包
- 🔧 **TypeScript**: 完整的类型定义
- 🧩 **ButtonGroup**: 支持按钮组合排列
- ⚡ **Tree-shakable**: 支持 ESM 和 CJS 双格式
- 🎯 **Loading/Disabled**: 内置加载和禁用状态

## 📦 安装

```bash
npm install @claw-ui/button
# 或
yarn add @claw-ui/button
# 或
pnpm add @claw-ui/button
```

## 🚀 快速开始

```tsx
import { Button } from '@claw-ui/button';
import '@claw-ui/button/styles.css';

function App() {
  return (
    <Button variant="primary" size="md" onClick={() => alert('Clicked!')}>
      Click Me
    </Button>
  );
}
```

## 📖 API

### Button Props

| 属性 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| `variant` | `'primary' \| 'secondary' \| 'outline' \| 'ghost' \| 'danger' \| 'link'` | `'primary'` | 按钮变体 |
| `size` | `'xs' \| 'sm' \| 'md' \| 'lg' \| 'xl'` | `'md'` | 按钮尺寸 |
| `shape` | `'default' \| 'round' \| 'circle' \| 'square'` | `'default'` | 按钮形状 |
| `block` | `boolean` | `false` | 是否撑满父容器 |
| `loading` | `boolean` | `false` | 加载状态 |
| `disabled` | `boolean` | `false` | 禁用状态 |
| `iconLeft` | `ReactNode` | - | 左侧图标 |
| `iconRight` | `ReactNode` | - | 右侧图标 |
| `icon` | `ReactNode` | - | 纯图标模式 |

> 同时支持所有原生 `<button>` HTML 属性。

### ButtonGroup Props

| 属性 | 类型 | 默认值 | 说明 |
|------|------|--------|------|
| `direction` | `'horizontal' \| 'vertical'` | `'horizontal'` | 排列方向 |

## 🎨 使用示例

### 变体

```tsx
<Button variant="primary">Primary</Button>
<Button variant="secondary">Secondary</Button>
<Button variant="outline">Outline</Button>
<Button variant="ghost">Ghost</Button>
<Button variant="danger">Danger</Button>
<Button variant="link">Link</Button>
```

### 尺寸

```tsx
<Button size="xs">Extra Small</Button>
<Button size="sm">Small</Button>
<Button size="md">Medium</Button>
<Button size="lg">Large</Button>
<Button size="xl">Extra Large</Button>
```

### 带图标

```tsx
<Button iconLeft={<StarIcon />}>Favorite</Button>
<Button iconRight={<ArrowIcon />}>Continue</Button>
<Button icon={<PlusIcon />} shape="circle" />
```

### 加载状态

```tsx
<Button loading>Submitting...</Button>
```

### 按钮组

```tsx
import { ButtonGroup, Button } from '@claw-ui/button';

<ButtonGroup>
  <Button variant="outline">Left</Button>
  <Button variant="outline">Center</Button>
  <Button variant="outline">Right</Button>
</ButtonGroup>
```

### 自定义主题

通过 CSS 变量自定义主题色：

```css
:root {
  --claw-color-primary: #6366f1;
  --claw-color-primary-hover: #4f46e5;
  --claw-color-primary-active: #4338ca;
  --claw-radius-md: 8px;
}
```

## 🔧 本地开发

```bash
# 安装依赖
npm install

# 启动 Storybook
npm run storybook

# 构建
npm run build
```

## 📄 License

MIT
npm package: @kawalcovid19/tailwind-preset-wbw
Description: Tailwind preset used across the Kawal COVID-19 + WargaBantuWarga projects.
Author: Kawal COVID-19
Latest version: 0.1.1

# tailwind-preset-wbw

Tailwind preset used across the Kawal COVID-19 + WargaBantuWarga projects.

## Installation

```bash
yarn add @kawalcovid19/tailwind-preset-wbw @tailwindcss/forms @tailwindcss/typography
```

## Usage

To use this preset, add this preset into the `presets` key in your project's `tailwind.config.js`:

```js
module.exports = {
  presets: [require('@kawalcovid19/tailwind-preset-wbw')],
  theme: {
    // ...
  },
};
```
npm package: @kawalir/extension
Description: Extension of TypeScript
Author: Denis Mijatovic
Latest version: 0.8.4

# Description

1. For browser and Node
2. Zero dependencies (may and probably will change)

# Installation

## 1. Install the Package

Install the package, e.g.

```
npm install @kawalir/extension
```

This will also set up globally available types to your TypeScript type checking, intellisense etc.

## 2. Import the Code

Import the extension in the first line of your program to load the code.

```ts
import "@kawalir/extension";

...
```
npm package: @kawalir/extension-node
Description: TypeScript Extension for Node
Author: Denis Mijatovic
Latest version: 0.6.7

# Description

Typescript extension for Node

# Installation

## 1. Install the Package

Install the package, e.g.

```shell
npm install @kawalir/extension-node
```

This will also set up globally available types to your TypeScript type checking, intellisense etc.

## 2. Import the Code

Import the extension in the first line of your program to load the code.

```ts
import "@kawalir/extension-node";

...
```
npm package: @kawanet/uuid
Description: All I need is UUID v4()
Author: @kawanet
Latest version: 8.3.0

# @kawanet/uuid
[![Node.js CI](https://github.com/kawanet/uuid/workflows/Node.js%20CI/badge.svg?branch=main)](https://github.com/kawanet/uuid/actions/)
[![npm version](https://badge.fury.io/js/@kawanet%2Fuuid.svg)](https://www.npmjs.com/package/@kawanet/uuid)

All I need is UUID v4()

## Node.js

```js
const uuidv4 = require("@kawanet/uuid").v4;

uuidv4(); // => 78180568-f312-470f-81a1-fda87ad939de
```

## TypeScript

```js
import {v4 as uuidv4} from "@kawanet/uuid";

uuidv4(); // => 78180568-f312-470f-81a1-fda87ad939de
```

## Browserify

Use [uuid](https://www.npmjs.com/package/uuid) on Node.js:

```js
const uuidv4 = require("uuid").v4;
```

Use tiny [@kawanet/uuid](https://www.npmjs.com/package/@kawanet/uuid) on browsers via [browserify](https://www.npmjs.com/package/browserify):

```json
{
  "browser": {
    "uuid": "@kawanet/uuid/uuid.js"
  }
}
```

## LINKS

- https://github.com/kawanet/uuid
- https://www.npmjs.com/package/@kawanet/uuid
- https://www.npmjs.com/package/uuid

## NOTE

- It uses lower 16-bit part of 32-bit `Math.random()` pseudo-random value.
  Use [uuid](https://www.npmjs.com/package/uuid) module instead, if you need a cryptographically-strong random value.
  See https://v8.dev/blog/math-random for the precision issue.

## LICENSE

MIT License

Copyright (c) 2021 Yusuke Kawasaki

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
npm package: @kawarimidoll/vuepress-plugin-tailwind
Description: A VuePress plugin to use tailwindcss easily
Author: kawarimidoll
Latest version: 2.0.0

# @kawarimidoll/vuepress-plugin-tailwind

[![GitHub package.json version](https://img.shields.io/github/package-json/v/kawarimidoll/vuepress-plugin-tailwind?logo=github&style=for-the-badge)](https://github.com/kawarimidoll/vuepress-plugin-tailwind/blob/master/package.json)
[![npm downloads](https://img.shields.io/npm/dt/@kawarimidoll/vuepress-plugin-tailwind?logo=npm&style=for-the-badge)](https://www.npmjs.com/package/@kawarimidoll/vuepress-plugin-tailwind)
[![Dependencies](https://img.shields.io/david/kawarimidoll/vuepress-plugin-tailwind?color=blue&logo=dependabot&style=for-the-badge)](https://github.com/kawarimidoll/vuepress-plugin-tailwind/pulls?q=dependabot)
[![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/kawarimidoll/vuepress-plugin-tailwind?logo=javascript&style=for-the-badge)](https://github.com/kawarimidoll/vuepress-plugin-tailwind/blob/master/index.js)
[![LICENSE](https://img.shields.io/github/license/kawarimidoll/vuepress-plugin-tailwind?style=for-the-badge)](https://github.com/kawarimidoll/vuepress-plugin-tailwind/blob/master/LICENSE)

A VuePress plugin to use [`tailwindcss`](https://github.com/tailwindcss/tailwindcss) easily.

With this plugin, you can use any classes defined by Tailwind CSS, and the unused classes are automatically purged (production only).

This plugin is based on [the official guide of Tailwind CSS](https://tailwindcss.com/docs/controlling-file-size/#removing-unused-css).

## Usage

1. Install this plugin :

```sh
yarn add @kawarimidoll/vuepress-plugin-tailwind
```

2. Add `@tailwind` import statements to the beginning of `.vuepress/styles/index.styl` :

```styl
@tailwind base;
@tailwind components;
@tailwind utilities;

// Add your style definitions below...
```

3. Load this plugin in `.vuepress/config.js` :

```js
module.exports = {
  plugins: [
    "@kawarimidoll/tailwind",
  ],
};
```

:warning:
_These configuration files are not created automatically. You have to create them if not exist._

## Options

See [docs](https://vuepress-plugin-tailwind.netlify.app).


## Versioning policy

Since v1.0.0, the versioning of this plugin will follow that of Tailwind.

For example, when there is a major version upgrade of Tailwind, this plugin also gets a major upgrade.

## License

[MIT](https://github.com/kawarimidoll/vuepress-plugin-tailwind/blob/master/LICENSE)
npm package: @kawaz/apex-bin
Description: Binary wrapper for apex
Author: Yoshiaki Kawazu
Latest version: 0.0.4

# apex-bin

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

## Install

```
npm install -g @kawaz/apex-bin
```

## Usage

The first time of execution is slow in order to download the latest version.

```shell-session
$ apex version
Apex version x.y.z
```


## Upgrade binary

This is the feature of apex.

```
apex upgrade
```
npm package: @kawaz/fixed-chunk-stream
Description: Transform streams into fixed-size chunks
Author: Yoshiaki Kawazu
Latest version: 0.1.1

# @kawaz/fixed-chunk-stream

A lightweight TypeScript library that transforms streams into fixed-size chunks. This utility class extends TransformStream to provide efficient chunking of byte streams with configurable behavior for handling incomplete chunks.

## Features

- Transform byte streams into fixed-size chunks
- TypeScript support with full type definitions
- Configurable handling of incomplete chunks at stream end
- Zero dependencies
- Works with Web Streams API

## Installation

```bash
# Using npm
npm install @kawaz/fixed-chunk-stream

# Using yarn
yarn add @kawaz/fixed-chunk-stream

# Using bun
bun add @kawaz/fixed-chunk-stream
```

## Usage

### Basic Example

```typescript
import { FixedChunkStream } from '@kawaz/fixed-chunk-stream';

// Create a stream that outputs 1KB chunks
const chunkStream = new FixedChunkStream(1024);

// Use it in a pipeline
await sourceStream
  .pipeThrough(chunkStream)
  .pipeTo(destinationStream);
```

### Handling Incomplete Chunks

By default, any remaining bytes that cannot form a complete chunk at the end of the stream are emitted as a smaller chunk. You can change this behavior by setting `discardIncompleteChunks` to `true`.

```typescript
// Discard incomplete chunks at the end of the stream
const chunkStream = new FixedChunkStream(1024, {
  discardIncompleteChunks: true
});
```

### Complete Example

```typescript
// Example: Reading a file in chunks
const response = await fetch('large-file.bin');
const reader = response.body
  .pipeThrough(new FixedChunkStream(1024))
  .getReader();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;

  // Each value is a Uint8Array of exactly 1024 bytes
  // (except possibly the last chunk if discardIncompleteChunks is false)
  console.log('Chunk size:', value.length);
}
```

## Development

This project uses [Bun](https://bun.sh) for development. Make sure you have it installed.

```bash
# Install dependencies
bun install

# Run tests
bun test

# Build the project
bun run build
```

## License

MIT License - see the [LICENSE](LICENSE) file for details

## Author

Yoshiaki Kawazu

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/amazing-feature`)
3. Commit your changes (`git commit -m 'Add some amazing feature'`)
4. Push to the branch (`git push origin feature/amazing-feature`)
5. Open a Pull Request

## Support

If you have any questions or run into issues, please open an issue on the [GitHub repository](https://github.com/kawaz/fixed-chunk-stream/issues).
npm package: @kawaz/linebreak
Description: An implementation of the Unicode Line Breaking Algorithm (UAX #14)
Author: Devon Govett
Latest version: 1.0.8

# linebreak
An implementation of the Unicode Line Breaking Algorithm (UAX #14)

> Line breaking, also known as word wrapping, is the process of breaking a section of text into lines such that it will fit in the
> available width of a page, window or other display area. The Unicode Line Breaking Algorithm performs part of this process.
> Given an input text, it produces a set of positions called "break opportunities" that are appropriate points to begin a new line.
> The selection of actual line break positions from the set of break opportunities is not covered by the Unicode Line Breaking Algorithm,
> but is in the domain of higher level software with knowledge of the available width and the display size of the text.

This is a JavaScript implementation of the
[Unicode Line Breaking Algorithm](http://www.unicode.org/reports/tr14/#SampleCode) for Node.js
(and browsers I guess).  It is used by [PDFKit](http://github.com/devongovett/pdfkit/) for
line wrapping text in PDF documents, but since the algorithm knows nothing about the actual
visual appearance or layout of text, it could be used for other things as well.

## Installation

You can install via npm

    npm install linebreak

## Example

```javascript
var LineBreaker = require('linebreak');

var lorem = 'lorem ipsum...';
var breaker = new LineBreaker(lorem);
var last = 0;
var bk;

while (bk = breaker.nextBreak()) {
  // get the string between the last break and this one
  var word = lorem.slice(last, bk.position);
  console.log(word);

  // you can also check bk.required to see if this was a required break...
  if (bk.required) {
    console.log('\n\n');
  }

  last = bk.position;
}
```

## Development Notes

In order to use the library, you shouldn't need to know this, but if you're interested in
contributing or fixing bugs, these things might be of interest.

* The `src/classes.js` file is automatically generated from `LineBreak.txt` in the Unicode
  database by `src/generate_data.js`. It should be rare that you need to run this, but
  you may if, for instance, you want to change the Unicode version.

* You can run the tests using `npm test`. They are written using `mocha`, and generated from
  `LineBreakTest.txt` from the Unicode database, which is included in the repository for performance
  reasons while running them. About 30 of the over 7000 tests are currently skipped due to
  implementation differences. It appears that some of the tests may be wrong or use different
  tailoring from the spec.

## License

MIT
npm package: @kawaz/mdp
Description: Terminal Markdown Preview CLI powered by MoonBit
Author: kawaz
Latest version: 0.1.13

# mdp

Terminal Markdown Preview CLI powered by [MoonBit](https://moonbitlang.com) and [mizchi/markdown.mbt](https://github.com/mizchi/markdown.mbt).

## Features

- ANSI color output for terminal
- Syntax highlighting for code blocks
- Tables, task lists, blockquotes
- Works with Node.js and Bun

## Installation

```bash
npm install -g @kawaz/mdp
```

## Usage

```bash
# Preview a file
mdp README.md

# Pipe from stdin
cat README.md | mdp

# With curl
curl -s https://raw.githubusercontent.com/kawaz/mdp/main/README.md | mdp
```

## Example Output

```
# Heading                    ← magenta + bold
## Subheading                ← blue + bold

This is **bold** and *italic* text.

  • Bullet point             ← yellow marker
  ☑ Completed task           ← green checkbox
  ☐ Pending task             ← gray checkbox

┌─ javascript ─────────────┐
│ const x = 1;             │  ← cyan code
└──────────────────────────┘

│ A blockquote             ← italic

| Name | Value |            ← table with borders
├──────┼───────┤
| foo  | 123   |
```

## Performance

| Runtime | Startup |
|---------|---------|
| Node.js | ~70ms   |
| Bun     | ~27ms   |

## Development

Requires [MoonBit](https://moonbitlang.com) toolchain.

```bash
# Build
just build

# Run locally
just run README.md

# Run with Bun
just run-bun README.md
```

## License

MIT
npm package: @kawaz/stream-bridge
Description: A utility library that provides bidirectional conversion between Node.js streams and Web Stream API streams
Author: Yoshiaki Kawazu
Latest version: 0.1.1

# @kawaz/stream-bridge

A utility library that provides bidirectional conversion between Node.js streams and Web Stream API streams.

## Features

- Convert Node.js streams to Web Stream API streams
- Convert Web Stream API streams to Node.js streams
- Written in TypeScript for type safety
- Zero external runtime dependencies
- Support for all major stream types

## Installation

```bash
# Using npm
npm install @kawaz/stream-bridge

# Using yarn
yarn add @kawaz/stream-bridge

# Using bun
bun add @kawaz/stream-bridge
```

## Usage

### Converting Node.js Streams to Web Streams

```typescript
import { toReadableStream, toWritableStream, toTransformStream } from '@kawaz/stream-bridge';
import { Readable, Writable, Transform } from 'node:stream';

// Convert to ReadableStream
const nodeReadable = new Readable();
const webReadable = toReadableStream(nodeReadable);

// Convert to WritableStream
const nodeWritable = new Writable();
const webWritable = toWritableStream(nodeWritable);

// Convert to TransformStream
const nodeTransform = new Transform();
const webTransform = toTransformStream(nodeTransform);
```

### Converting Web Streams to Node.js Streams

```typescript
import { toReadable, toWritable, toTransform } from '@kawaz/stream-bridge';

// Convert to Readable
const webReadable = new ReadableStream();
const nodeReadable = toReadable(webReadable);

// Convert to Writable
const webWritable = new WritableStream();
const nodeWritable = toWritable(webWritable);

// Convert to Transform
const webTransform = new TransformStream();
const nodeTransform = toTransform(webTransform);
```

## API

### Node.js → Web Stream

- `toReadableStream<T>(readable: Readable): ReadableStream<T>`
- `toWritableStream<T>(writable: Writable): WritableStream<T>`
- `toTransformStream<T, O>(duplex: Transform|Duplex): TransformStream<T, O>`
- `toReadableWritablePair<R, W>(duplex: Duplex): ReadableWritablePair<R, W>`

### Web Stream → Node.js

- `toReadable(readableStream: ReadableStream, options?): Readable`
- `toWritable(writableStream: WritableStream, options?): Writable`
- `toTransform(transformStream: TransformStream, options?): Transform`
- `toDuplex(transformStream: TransformStream, options?): Duplex`

## License

MIT © Yoshiaki Kawazu

## Contributing

Please report bugs and feature requests in the [GitHub Issues](https://github.com/kawaz/stream-bridge/issues).
Pull requests are welcome.

## Development

```bash
# Install dependencies
bun install

# Run tests
bun test

# Build
bun run build
```
npm package: @kawaz/worker-timer
Description: setTimeout/setInterval with worker
Latest version: 1.0.1

# @kawaz/worker-timer

A library that executes `setTimeout` and `setInterval` in Web Workers.

## Features

- Provides `setTimeout` and `setInterval` that don't slack off even when the browser tab is in the background
- Uses the same API as the standard `setTimeout` and `setInterval`
- Fully supported in TypeScript
npm package: @kawaz/zunlib
Description: A collection of small utility functions and types for JavaScript/TypeScript
Author: kawaz
Latest version: 0.0.4

# @kawaz/zunlib

A collection of small utility functions and types for JavaScript/TypeScript.

## Installation

```bash
bun add @kawaz/zunlib
# or
npm install @kawaz/zunlib
```

## Utilities

- checkAll - Check multiple conditions simultaneously
- debounce - Debounce function calls
- matcher - Keyword/pattern matcher with wildcard support
- resolveAll - Resolve multiple getters/Promises simultaneously
- throttle - Throttle function calls
- valueOrGetter - Unified handling of values or getter functions
- wait - Polling, condition waiting, and value waiting utilities

## Planned Utilities

- binconv - Binary conversion utilities
- worker - Web Worker helpers
- duckdb - DuckDB utilities
- datetime - Date/time utilities

## Development

```bash
bun install      # Install dependencies
bun run lint     # Run linter
bun test         # Run tests
bun run build    # Build for production
```

## License

MIT
npm package: @kawix/core
Description: The next generation module loader for nodejs
Author: Kodhe
Latest version: 1.0.3

# @kawix/core

### The next generation module loader for nodejs

### no-webpack, no-rollup, no-dependencies

**@kawix/core** allows requiring modules in async and more elegant way, and use last features of EcmaScript (for example async/await) without requiring a lot of dependencies, packagers or build scripts


## DEPRECATED

Now you can use the new project ```kwruntime``` is similar to ```@kawix/core``` in many aspects, but more modern, better code, more features, and better dependency management.

Go to [https://github.com/kwruntime/core](https://github.com/kwruntime/core)


## More info

Please go to [https://github.com/kodhework/kawix](https://github.com/kodhework/kawix) for see the full **kawix** project


## Instalation and Documentation

* [INSTALL.md](https://github.com/kodhework/kawix/blob/master/core/INSTALL.md)
* [DOCS.md](https://github.com/kodhework/kawix/blob/master/core/DOCS.md)
* [CHANGES.md](https://github.com/kodhework/kawix/blob/master/core/CHANGES.md)


## Usage from node

```javascript
require("@kawix/core")
global.kawix.KModule.import("/path/to/script.ts").then(function(exports){
	console.info("Result:", exports)
}).catch(console.error)
```

## Do you want contribute?

You can contribute testing the code and report issues: [https://github.com/kodhework/kawix/issues](https://github.com/kodhework/kawix/issues)

Do you think that can write better some parts of this README? Feel free to check and contribute

Do you have any idea that can be great for this project?

If you are a developer with time, can contribute adding functionality or fixing some bugs that can appears

If you cannot contribute in last two ways, why not donate? Contact us: contacto@kodhe.com

Do you want appears on README section like a continous financial collaborator, contact us for patronate this project with monthly donations
npm package: @kawkab-oss/stcpay-node
Description: STC Pay direct payment implementation for Node.
Author: Kawkab
Latest version: 1.1.2

# STC Pay Node.js SDK

STC Pay direct payment implementation for Node.

## Installation
```sh
npm install @kawkab-oss/stcpay-node
yarn add @kawkab-oss/stcpay-node
```

## Usage
```ts
const stcpay = new STCPay({
  merchantId: YOUR_MERCHANT_ID,
  cert: readFileSync('cert.pem', 'utf8'),
  key: readFileSync('key.pem', 'utf8'),
  testing: true
});

const response = await stcpay.authorize(CUSTOMER_PHONE_NUMBER, PAYMENT_AMOUNT, {
  BranchID: 'string',
  TellerID: 'string',
  DeviceID: 'string',
  RefNum: 'string',
  BillNumber: 'string'
});

await stcpay.confirm(response.STCPayPmtReference, response.OtpReference, OTP_FROM_CUSTOMER);
```
npm package: @kaws128mir/fantoms-multicall
Description: Make multiple Fantom network requests in a single HTTP query. ethcall for ethers v5.
Author: kaws128mir
Latest version: 0.0.1

# ethers-multicall

Make multiple Ethereum network requests in a single HTTP query. [ethcall](https://github.com/Destiner/ethcall) for ethers v5.

## API

* `Contract(address, abi)`: Create contract instance; calling `contract.callFuncName` will yield a `call` object
* `all(calls)`: Execute all calls in a single request
* `calls`: List of helper call methods
* `getEthBalance(address)`: Returns account ether balance

## Example

```ts
import { Contract, Provider } from 'ethers-multicall';
import { ethers } from 'ethers';

import erc20Abi from './abi/erc20.json';

const infuraKey = 'INSERT_YOUR_KEY_HERE';
const provider = new ethers.providers.InfuraProvider('mainnet', infuraKey);

const daiAddress = '0x6b175474e89094c44da98b954eedeac495271d0f';

async function call() {
  const ethcallProvider = new Provider(provider);

  await ethcallProvider.init(); // Only required when `chainId` is not provided in the `Provider` constructor

  const daiContract = new Contract(daiAddress, erc20Abi);

  const uniswapDaiPool = '0x2a1530c4c41db0b0b2bb646cb5eb1a67b7158667';

  const ethBalanceCall = ethcallProvider.getEthBalance(uniswapDaiPool);
  const daiBalanceCall = daiContract.balanceOf(uniswapDaiPool);

  const [ethBalance, daiBalance] = await ethcallProvider.all([ethBalanceCall, daiBalanceCall]);

  console.log('ETH Balance:', ethBalance.toString());
  console.log('DAI Balance:', daiBalance.toString());
}

call();
```
npm package: @kawsar-ahmed/open-api-mcp-server
Description: CLI for interacting with MCP server APIs
Author: Kawsar Ahmed
Latest version: 1.0.1

# Open API MCP Server

This project is a Model Context Protocol (MCP) server that dynamically loads and exposes tools based on an OpenAPI (Swagger) specification. It is designed to help you interact with, inspect, and test any OpenAPI-compatible API via a standard interface.

## Features

- **Dynamic Swagger/OpenAPI loading:** Pass a Swagger JSON URL as a command-line argument to load and interact with any API.
- **API Inspection Tools:**
  - `list_apis`: List all available API paths.
  - `get_api_info`: Get detailed information about a specific API endpoint, including parameters and request/response schemas.
  - `list_endpoints`: List endpoints with optional filtering by method or path substring.
  - `load_swagger_spec`: Fetch and return the full Swagger spec.
  - `readSwaggerSpec`: Fetch and pretty-print the loaded Swagger spec.
- **Request Body Example Generation:** For endpoints with a request body, the server generates a sample JSON payload based on the schema.
- **Standard I/O Transport:** The server communicates over stdin/stdout, making it easy to integrate with other tools or automation.

## Usage

### 1. Install dependencies

```sh
npm install
```

### 2. Build the project

```sh
npm run build
```

### 3. Run the server with a Swagger JSON URL

```sh
node dist/index.js <swagger-json-url>
```

Example:

```sh
node dist/index.js http://your-server.com/swagger/v1/swagger.json
```

## Example Tools

- **list_apis**: Returns all API paths from the loaded spec.
- **get_api_info**: Returns details (parameters, request/response, sample body) for a given endpoint.
- **list_endpoints**: Returns endpoints, optionally filtered by HTTP method or path substring.
- **readSwaggerSpec**: Returns the full Swagger spec as formatted JSON.

## Development

- Written in TypeScript
- Uses `node-fetch` for HTTP requests
- Uses `zod` for schema validation

## Project Structure

- `src/index.ts`: Main server and tool logic
- `dist/`: Compiled JavaScript output
- `.gitignore`: Standard Node/TypeScript ignores
- `tsconfig.json`: TypeScript configuration

## License

ISC

## Configuration & CLI Usage

You can use this project as a CLI tool to load and interact with any OpenAPI/Swagger spec. You can run it directly with `npx` or as a local/global package.

### Example: Using with npx

```sh
npx @kawsar-ahmed/open-api-mcp-server http://your-server.com/swagger/v1/swagger.json
```

### Example: Using in a config file (e.g., mcp.json)

You can configure your tool runner (such as Cursor or any MCP-compatible orchestrator) to use this server with a config like:

```json
{
  "mcpServers": {
    "swagger2": {
      "command": "npx",
      "args": ["@kawsar-ahmed/open-api-mcp-server", "http://your-server.com/swagger/v1/swagger.json"]
    }
  }
}
```

Replace the URL with your actual Swagger/OpenAPI endpoint.

---

**Author:** Kawsar Ahmed
npm package: @kaxline/redux-orm-proptypes
Description: React PropTypes validation and defaultProps mixin for Redux-ORM Models
Author: Tommi Kaikkonen
Latest version: 0.1.1

redux-orm-proptypes
===============

Provides type checking using React PropTypes and declaring default properties with defaultProps in [Redux-ORM](https://github.com/tommikaikkonen/redux-orm). 

## Installation

```bash
npm install redux-orm-proptypes --save
```

## Usage

Import.

```javascript
import { PropTypes } from 'React';
import { Model } from 'redux-orm';
import propTypesMixin from 'redux-orm-proptypes';
```

Use the mixin function which returns a class with PropTypes and defaultProps logic added.

```javascript
const ValidatingModel = propTypesMixin(Model);
```

Define your concrete model, and add `propTypes` and `defaultProps` static class attributes.

```javascript
class Person extends ValidatingModel {}
Person.propTypes = {
    name: PropTypes.string.isRequired,
    age: PropTypes.number.isRequired,
    isFetching: PropTypes.bool.isRequired,
};

Person.defaultProps = {
    isFetching: false,
};

Person.modelName = 'Person';
```

The mixin adds a layer of logic on top of the Model static method `create` and the instance method `update`. When calling `create`, if you have defined `defaultProps`, it'll merge the defaults with the props you passed in. Then, if you've defined `Model.propTypes`, it'll validate the props. The final props (that may have been merged with defaults) will be passed to the `create` method on the superclass you passed the mixin function.

When you call the `modelInstance.update(attrObj)` instance method, the keys in `attrObj` will be checked against the corresponding `propTypes`, if they exist.

An example of the usage inside a reducer (or a session):

```javascript
Person.create({name: 'Tommi', age: `I don't know!`});
// Error: Invalid prop `age` of type `string` supplied to `Person.create`, expected `number`.

const instance = Person.create({ name: 'Tommi', age: 25 });
console.log(instance.isFetching);
// false

instance.update({ age: `I don't know!` });
// Error: Invalid prop `age` of type `string` supplied to `Person.update`, expected `number`.
```

## Options

You can explicitly toggle either of the features by importing the mixin factory function `getPropTypesMixin` and creating your own version of the mixin by passing an options object.

```javascript
import { Model } from 'redux-orm';
import { getPropTypesMixin } from 'redux-orm-proptypes';

const myPropTypesMixin = getPropTypesMixin({ validate: false, useDefaults: true});
const ValidatingModel = myPropTypesMixin(Model);
```

## License

MIT. See `LICENSE`
npm package: @kayaabadiv/fingerprint
Description: A lightweight, robust browser fingerprinting library.
Author: kayaabadiv
Latest version: 1.0.2

# TheSeed Fingerprint

A lightweight, robust, and privacy-focused browser fingerprinting library. It generates a unique visitor identifier based on various browser attributes without using cookies or local storage.

## Features

- **Canvas Fingerprinting**: Draws hidden text and shapes to detect rendering differences.
- **Audio Context Fingerprinting (Enhanced)**: Uses `OfflineAudioContext` with a complex oscillator/compressor setup to detect audio hardware signatures. High sensitivity to minor driver/hardware differences.
- **WebGL Fingerprinting**: Extracts GPU vendor and renderer information.
- **Browser Environment**: Collects screen resolution, hardware concurrency, user agent, timezone, etc.
- **No External Dependencies**: Pure TypeScript/JavaScript implementation.

## Installation

```bash
npm install @kayaabadev/fingerprint
# or
yarn add @kayaabadev/fingerprint
```

## Usage

### Basic Example

```typescript
import { generateFingerprint } from '@kayaabadev/fingerprint';

async function identifyUser() {
  // Generate the fingerprint
  const result = await generateFingerprint();

  if (result) {
    console.log('Visitor ID:', result.visitorId);
    console.log('Detailed Components:', result.components);
  } else {
    console.error('Fingerprinting failed (not in a browser environment?)');
  }
}

identifyUser();
```

### React Example

```tsx
import { useEffect, useState } from 'react';
import { generateFingerprint } from '@kayaabadev/fingerprint';

export const useVisitorId = () => {
  const [visitorId, setVisitorId] = useState<string | null>(null);

  useEffect(() => {
    generateFingerprint().then((result) => {
      if (result) {
        setVisitorId(result.visitorId);
      }
    });
  }, []);

  return visitorId;
};
```

## Returned Data Structure

The `generateFingerprint` function returns a Promise that resolves to an object (or `null` if server-side):

```typescript
{
  visitorId: string; // A 32-bit hex hash (e.g., "a1b2c3d4")
  components: {
    canvas: string | null;       // Data URL of the rendered canvas
    audio: string | null;        // Hash of the audio buffer
    webgl: string | null;        // GPU Vendor ~ Renderer
    userAgent: string;
    language: string;
    platform: string;
    screenResolution: string;    // "1920x1080"
    colorDepth: number;
    timezone: string;            // "Europe/Paris"
    touchSupport: boolean;
    hardwareConcurrency: number; // Number of logical cores
    deviceMemory?: number;       // Approximate RAM in GB
  }
}
```

## Privacy Note

This library is intended for fraud detection, personalization, and analytics. Always ensure you comply with local privacy regulations (GDPR, CCPA, etc.) when collecting user data.

## Credits

Powered by [theseed.dev](https://theseed.dev).

## License

MIT
npm package: @kayac/generate-password
Description: generate random secure password
Author: kayac-chang
Latest version: 0.1.1

# Password Generator

## Generate Rule

- Contain at least one uppercase character (A-Z).
- Contain at least one lowercase character (a-z).
- Contain at least one digit (0-9).
- Contain at least one symbol (~!@#$%^&\*\_-+=`|(){}[]:;"'<>,.?/).
npm package: @kayac/run-with-log
Description: wrap function with custom log message function
Author: kayac-chang
Latest version: 1.0.1

# Run With Log

wrap function with custom log message function.

## Install

```
npm install @kaya/run-with-log
```

## Usage

```js
import runWithLog from "@kaya/run-with-log";

const add = (a, b) => a + b;

const addWithLog = runWithLog(
  ([x, y], result) => `${x} + ${y} = ${result}`,
  add
);

const result = addWithLog(1, 1); //=> print "1 + 1 = 2"
// result === 2
```
npm package: @kayahr/aseprite
Description: A set of TypeScript interfaces and enums, API documentation, JSON file typings and JSON schema for Aseprite JSON files
Author: Klaus Reimer
Latest version: 2.1.0

aseprite
========

[GitHub] | [NPM] | [API Doc]

A set of TypeScript interfaces and enums, API documentation, JSON file typings and JSON schema for [Aseprite] JSON files.

Installation
------------

```sh
npm install @kayahr/aseprite
```

Types
-----

You can use the provided interfaces and enums to work with Aseprite JSON data in a type-safe way:

```typescript
import * as aseprite from "@kayahr/aseprite";

const response = await fetch("spaceship.aseprite.json");
const spaceship = (await response.json()) as aseprite.SpriteSheet;
const image = spaceship.meta.image;
const isRGBA = spaceship.meta.format === aseprite.Format.RGBA8888;
```

JSON file typings
-----------------

This project provides typings for JSON files with the file pattern `*.aseprite.json`. So when you name your JSON files like this and your module loader supports importing JSON files then you can import the sprite sheets right away and TypeScript already knows the type and can validate your code:

```typescript
import * as aseprite from "@kayahr/aseprite";
import spaceship from "../sprites/spaceship.aseprite.json" with { type: "json" };

const image = spaceship.meta.image;
const isRGBA = spaceship.meta.format === aseprite.Format.RGBA8888;
```

Note that you have to import `@kayahr/aseprite` somewhere in your application at least once or otherwise TypeScript doesn't load the typings for `*.aseprite.json` files. If you don't actually need to import an actual type then simply do `import "@kayahr/aseprite"` somewhere in your code or add `node_modules/@kayahr/aseprite/typings/aseprite.json.d.ts` to the include list in your `tsconfig.json`.

JSON schema
-----------

In case you want to validate Aseprite JSON files or benefit from completion while editing these files there is also a [JSON schema file](https://kayahr.github.io/aseprite/aseprite.schema.json) which is automatically generated from the TypeScript types.

You can also access the schema file via your module loader by importing `@kayahr/aseprite/aseprite.schema.json`.

API documentation
-----------------

The interfaces and enums describing the Aseprite JSON format are documented so VSCode displays the documentation during completion and in tooltips. There is also a [HTML API documentation](https://kayahr.github.io/aseprite/).


[API Doc]: https://kayahr.github.io/aseprite/
[GitHub]: https://github.com/kayahr/aseprite
[NPM]: https://www.npmjs.com/package/@kayahr/aseprite
[Aseprite]: https://www.aseprite.org/
npm package: @kayahr/assert
Description: A large collection of generic TypeScript assert functions which can be used in unit tests but also in production code to validate inputs for example.
Author: Klaus Reimer
Latest version: 1.4.1

# Assert

[GitHub] | [NPM] | [API Doc]

A large collection of generic TypeScript assert functions which can be used in unit tests but also in production code to validate inputs for example.

When an assertion fails an [AssertionError] is thrown with detailed information about what went wrong.

The assert library works in Node.js and browsers.


## Usage

Install the library in your project (add `-D` parameter when only needed as dev dependency for unit tests):

```bash
npm install @kayahr/assert
```

And the use it like this:

```typescript
import { assertNotNull } from "@kayahr/assert";

assertNotNull(someValue);
```

See [API Doc] for a list of all provided assert functions.

[API Doc]: https://kayahr.github.io/assert/
[GitHub]: https://github.com/kayahr/assert/
[NPM]: https://www.npmjs.com/package/@kayahr/assert/
[AssertionError]: https://kayahr.github.io/assert/classes/AssertionError.html
npm package: @kayahr/better-jest
Description: Jest wrapper to start jest with exposed garbage collector and options from JEST_OPTS environment variable
Author: Klaus Reimer
Latest version: 1.2.1
Deprecated: Package no longer maintained

better-jest
===========

This is just wrapper script around [Jest](https://jestjs.io/) to start Jest with exposed garbage-collector and passing additional arguments from the JEST_OPTS environment variable.

Usage
-----

Install better-jest into your project:

    npm install -D @kayahr/better-jest

Use `better-jest` instead of `jest` in your `package.json`:

    "scripts": {
        "test": "better-jest",
    }

That's it.

Garbage collector
-----------------

By using better-jest you can use the `gc()` function within your Node.js tests or in Electron tests when using my [jest-electron-runner](https://www.npmjs.com/package/@kayahr/jest-electron-runner)

Environment variables
---------------------

You can define Jest options globally with the environment variable JEST_OPTS and these options will then be picked up by better-jest and passed to Jest. This is for example helpful for CI systems which have specific needs for running the tests, like limiting the number of parallel workers when the CI host has an insane number of CPU cores. It is easier to globally define this environment variable instead of configuring each build job separately.

    # Do this somewhere global on your system
    export JEST_OPTS="--max-workers 1"

    # Then run your tests in all your projects and Jest is now
    # limited to a single worker thread automatically
    npm test
npm package: @kayahr/create-project
Description: Template for kayahr typescript projects
Author: Klaus Reimer
Latest version: 2.2.0

# Kayahr Project Template

To create a new @kayahr project run this:

    npm init @kayahr/project@latest <project-directory>

This performs the following steps:

* Create new project directory
* Copy the project template files into it and replace template variables like the project name (derived from last part of project directory)
* Installs the newest versions of all project dependencies
* Builds the new project for the first time
* Runs all tests and generates API doc for the first time
npm package: @kayahr/cspell
Description: A drop-in replacement for cspell, bundling cspell and its many dependencies into a single module
Author: Klaus Reimer
Latest version: 9.7.0-bundle.1

# @kayahr/cspell

[GitHub] | [NPM]

A drop-in replacement for [cspell], bundling cspell and its many dependencies into a single module.

This package is primarily for my own use as a single dev dependency across my projects, to centralize the review of updates for the many dependencies that cspell brings along, and to reduce the threat of a supply-chain attack. Use at your own risk.

Usage
-----

Install as development dependency:

```
npm install -DE @kayahr/cspell
```

Usage is the same as with the original [cspell], so check upstream documentation for more info.

[GitHub]: https://github.com/kayahr/cspell
[NPM]: https://www.npmjs.com/package/@kayahr/cspell
[cspell]: https://www.npmjs.com/package/cspell