open-index/open-npm huggingface dataset:
npm package: @kyneticbio/core
Description: Core simulation library for KyneticBio
Author: KyneticBio
Latest version: 1.0.0

# @kyneticbio/core

The core simulation engine for KyneticBio.

## Installation

```bash
npm install @kyneticbio/core
```

## Usage

```typescript
import { Engine } from '@kyneticbio/core';

// Initialize engine
const engine = new Engine();
```
npm package: @kynsonszetau/lint
Description: Lint configurations used in Kynson Szetau's projects
Author: Kynson Szetau
Latest version: 3.0.0

# Lint
![Code style: Prettier](https://img.shields.io/badge/code_style-Prettier-blue?style=for-the-badge)
![License: MIT](https://img.shields.io/github/license/Kynson/lint?style=for-the-badge)

Lint configurations used in Kynson Szetau's projects. Contains Javascript and Typescript rules. While this package is intended for my personal projects, feel free to install this package if you find it fits your projects needs.
npm package: @kynsonszetau/png2webp
Description: A simple WASM library designed to convert PNG images to WebP format.
Author: Kynson Szetau
Latest version: 1.0.1

# png2webp

This is a simple WASM library designed to convert PNG images to WebP format.

## Usage

Brower & Node.js:
```js
import init from '@kynsonszetau/png2webp';
import { png2webp } from '@kynsonszetau/png2webp';

await init();

// data is an Uint8Array containing PNG data
png2webp(data);
```
Cloudflare Workers:
```js
import { png2webp, initSync } from '@kynsonszetau/png2webp';
// Cloudflare workers does not support compiling WASM bytecode during runtime
// We have to initialize it in a different way
import png2webpWasm from '@kynsonszetau/png2webp/png2webp_bg.wasm';

initSync(png2webpWasm);

png2webp(data);
```
Function signatures of the above functions are included in png2webp.min.d.mts

## How it works

The main functionality of this project is provided by the `png2webp` function in the [src/lib.rs](src/lib.rs) file. This function takes a PNG image data as input and returns the converted WebP image data.

The function uses `image` crate for handling the image conversion. The `wasm-bindgen` crate is used to provide a bridge between Rust and JavaScript, allowing the `png2webp` function to be called from JavaScript code as WASM.

## Building the Project

To build the project, you can use the `wasm-pack` command-line tool:

```sh
wasm-pack build --target web
```

Or use the build script included in the [repository](https://github.com/Kynson/png2webp):

```sh
npm run build
```
npm package: @kyntocg/river
Description: Composable command engine inspired by Brigadier for frontend, backend, CLI and MCP
Latest version: 0.2.2

# River

River is a command engine inspired by Brigadier, designed to run the same command definitions across frontend, backend, CLI, and MCP/skills.

## Features
- Declarative command specs with literal and argument segments.
- Incremental parser and dispatcher.
- Token-level suggestions for autocomplete and tab-complete flows.
- Greedy arguments for Discord-style free text payloads.
- Named options/flags (`--status done`, `-s done`) with typed parsing.
- Fuzzy literal suggestions (typo tolerant).
- Default arguments: `int`, `float`, `boolean`, `enum`, `rangeInt`, `rangeFloat`.
- Default options: `boolean`, `int`, `float`, `string`.
- Backend reader to parse and dispatch command envelopes from API/queue/CLI.

## Install

```bash
npm install @kyntocg/river
```

## Quick Example

```ts
import {
  command,
  literal,
  argument,
  defaultArguments,
  enumSuggestions,
  dispatchCommand,
  RiverBackendReader,
} from "@kyntocg/river";

const specs = [
  command({
    id: "math.scale",
    description: "Scale values by numeric range",
    segments: [
      literal("scale"),
      argument("range", { parse: defaultArguments.rangeInt({ min: 1, max: 1000 }) }),
      argument("mode", {
        parse: defaultArguments.enum(["linear", "log"] as const),
        suggest: enumSuggestions(["linear", "log"] as const),
      }),
    ],
    execute: async (_ctx, args) => args,
  }),
];

await dispatchCommand("scale 10..50 linear", specs, {});

const reader = new RiverBackendReader(specs, (envelope) => ({ actorId: envelope.actorId }));
await reader.dispatch({ command: "scale 10..20 log", actorId: "u_123" });
```

## Build Commands

```bash
npm install
npm run verify
npm run build
npm run typecheck
npm run pack:dry
```

## Publish Flow

### First-time setup
```bash
npm login
```

### Release a new version
```bash
npm run release:patch
# or: npm run release:minor
# or: npm run release:major
```

### Publish
```bash
npm run publish:public
```

## Install In Killio Projects

### Killio Frontend
```bash
cd ../Killio-Frontend
npm install @kyntocg/river
```

### Killio Backend
```bash
cd ../Killio-Backend
npm install @kyntocg/river
```

## Exports
- `@kyntocg/river`
  - Core: types, builders, tokenizer, parser, suggester, default arguments
  - Runtime: contracts, backend reader
npm package: @kyo-ago/react-textfit
Description: React component to fit headlines and paragraphs into any element
Author: kyo-ago
Latest version: 2.0.0

react-textfit
=========================

[![npm](https://img.shields.io/badge/npm-react--textfit-brightgreen.svg?style=flat-square)]()
[![npm version](https://img.shields.io/npm/v/react-textfit.svg?style=flat-square)](https://www.npmjs.com/package/react-textfit)
[![npm downloads](https://img.shields.io/npm/dm/react-textfit.svg?style=flat-square)](https://www.npmjs.com/package/react-textfit)

* fit **headlines and paragraphs** into any element
* **fast:** uses binary search for efficiently find the correct fit
* **100%** react-goodness
* works with **any style** configuration (line-height, padding, ...)
* **[check out the demo](http://malte-wessel.github.io/react-textfit/)**

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Modes](#modes)
- [API](#api)
- [License](#license)

## Installation
```bash
npm install react-textfit --save
```

## Usage

### Headlines

```javascript
import { Textfit } from 'react-textfit';

class App extends Component {
  render() {
    return (
      <Textfit mode="single">
        Fat headline!
      </Textfit>
    );
  }
}
```

#### Respect the element's height when using single lines

```javascript
import { Textfit } from 'react-textfit';

class App extends Component {
  render() {
    return (
      <Textfit
        mode="single"
        forceSingleModeWidth={false}>
        Fat headline!
      </Textfit>
    );
  }
}
```

### Paragraphs

```javascript
import { Textfit } from 'react-textfit';

class App extends Component {
  render() {
    return (
      <Textfit mode="multi">
        Lorem <strong>ipsum</strong> dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
      </Textfit>
    );
  }
}
```

## Modes

### `single`

**Algorithm steps:**
```
1. binary search to fit the element's width
2. if forceSingleModeWidth=false and text overflows height
    2a. binary search to also fit the elements height
```

### `multi`

**Algorithm steps:**
```
1. binary search to fit the element's height
2. if text overflows width
    2a. binary search to also fit the elements width
```

## API

### `<Textfit>`

#### Props

* `mode` (single|multi) Algorithm to fit the text. Use single for headlines and multi for paragraphs. Default is `multi`.
* `forceSingleModeWidth` (Boolean) When mode is single and forceSingleModeWidth is true, the element's height will be ignored. Default is `true`.
* `min` (Number) Minimum font size in pixel. Default is `1`.
* `max` (Number) Maximum font size in pixel. Default is `100`.
* `throttle` (Number) Window resize throttle in milliseconds. Default is `50`.
* `onReady` (Function) Will be called when text is fitted.

## License

MIT
npm package: @kyo_ago/react-loading-bar
Description: react loading bar
Author: kyo-ago
Latest version: 1.0.0

# React Loading Bar

## Usage

```
  npm install @kyo_ago/react-loading-bar --save
```


```
import React, { Component } from 'react'
import Loading from '@kyo_ago/react-loading-bar'
import '@kyo_ago/react-loading-bar/dist/index.css'

export default class LoadingExample extends Component {
  state = {
    show: false
  }

  onShow = ()=> {
    this.setState({ show: true })
  }

  onHide = ()=> {
    this.setState({ show: false })
  }

  render() {
    return (
      <div>
        <Loading
          show={this.state.show}
          color="red"
        />

        <button
          type="button"
          onClick={this.onShow}>
          show
        </button>

        <button
          type="button"
          onClick={this.onHide}>
          hide
        </button>
      </div>
    )
  }
}
```

Support UMD

## Demo

[React Loading Bar Example](http://lonelyclick.github.io/examples/loadingbar.html "react-loading-bar")

## Option Change

```
<Loading
  show={true}
  color="red"
  change={false}
  showSpinner={true}
/>
```

If change set `false`, will do nothing, default `true`

## License

MIT
npm package: @kyo_ago/react-textfit
Description: React component to fit headlines and paragraphs into any element
Author: kyo-ago
Latest version: 3.0.0

react-textfit
=========================

[![npm](https://img.shields.io/badge/npm-react--textfit-brightgreen.svg?style=flat-square)]()
[![npm version](https://img.shields.io/npm/v/react-textfit.svg?style=flat-square)](https://www.npmjs.com/package/react-textfit)
[![npm downloads](https://img.shields.io/npm/dm/react-textfit.svg?style=flat-square)](https://www.npmjs.com/package/react-textfit)

* fit **headlines and paragraphs** into any element
* **fast:** uses binary search for efficiently find the correct fit
* **100%** react-goodness
* works with **any style** configuration (line-height, padding, ...)
* **[check out the demo](http://malte-wessel.github.io/react-textfit/)**

## Table of Contents

- [Installation](#installation)
- [Usage](#usage)
- [Modes](#modes)
- [API](#api)
- [License](#license)

## Installation
```bash
npm install react-textfit --save
```

## Usage

### Headlines

```javascript
import { Textfit } from 'react-textfit';

class App extends Component {
  render() {
    return (
      <Textfit mode="single">
        Fat headline!
      </Textfit>
    );
  }
}
```

#### Respect the element's height when using single lines

```javascript
import { Textfit } from 'react-textfit';

class App extends Component {
  render() {
    return (
      <Textfit
        mode="single"
        forceSingleModeWidth={false}>
        Fat headline!
      </Textfit>
    );
  }
}
```

### Paragraphs

```javascript
import { Textfit } from 'react-textfit';

class App extends Component {
  render() {
    return (
      <Textfit mode="multi">
        Lorem <strong>ipsum</strong> dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
      </Textfit>
    );
  }
}
```

## Modes

### `single`

**Algorithm steps:**
```
1. binary search to fit the element's width
2. if forceSingleModeWidth=false and text overflows height
    2a. binary search to also fit the elements height
```

### `multi`

**Algorithm steps:**
```
1. binary search to fit the element's height
2. if text overflows width
    2a. binary search to also fit the elements width
```

## API

### `<Textfit>`

#### Props

* `mode` (single|multi) Algorithm to fit the text. Use single for headlines and multi for paragraphs. Default is `multi`.
* `forceSingleModeWidth` (Boolean) When mode is single and forceSingleModeWidth is true, the element's height will be ignored. Default is `true`.
* `min` (Number) Minimum font size in pixel. Default is `1`.
* `max` (Number) Maximum font size in pixel. Default is `100`.
* `throttle` (Number) Window resize throttle in milliseconds. Default is `50`.
* `onReady` (Function) Will be called when text is fitted.

## License

MIT
npm package: @kyoheig3/tneedle
Description: Type-safe dependency injection resolver for tsyringe
Author: KyoheiG3
Latest version: 0.0.3

# tneedle

**English** | [日本語](./README.ja.md)

Type-safe dependency injection resolver for [tsyringe](https://github.com/microsoft/tsyringe).

## Features

- Lightweight wrapper around `tsyringe` container
- Type-safe access to registered instances
- Unique `Symbol` tokens for each resolver (no token conflicts)
- Late binding support with `register()` method
- Works with interfaces (no decorators required)

## Installation

```bash
npm install @kyoheig3/tneedle tsyringe reflect-metadata
```

### Peer Dependencies

- `tsyringe` ^4.0.0
- `reflect-metadata` ^0.1.13 || ^0.2.0

## Setup

Import `reflect-metadata` at your application entry point:

```typescript
import "reflect-metadata";
```

## Usage

### Basic Usage

```typescript
import { createResolver } from "@kyoheig3/tneedle";

// Define your interface
interface UserRepository {
  findById(id: string): Promise<User | null>;
  save(user: User): Promise<void>;
}

// Create a resolver
export const userRepo = createResolver<UserRepository>();

// Register implementation at app startup
userRepo.register({
  findById: async (id) => {
    /* ... */
  },
  save: async (user) => {
    /* ... */
  },
});

// Use anywhere in your app
const user = await userRepo.findById("123");
```

### With Initial Value

```typescript
const config = createResolver({
  apiUrl: "https://api.example.com",
  timeout: 5000,
});

// Immediately accessible
console.log(config.apiUrl);

// Can be overridden later
config.register({
  apiUrl: "https://staging.example.com",
  timeout: 10000,
});
```

### Clean Architecture Example

```typescript
// domain/repositories.ts
export const userRepository = createResolver<UserRepository>();
export const orderRepository = createResolver<OrderRepository>();

// infrastructure/setup.ts
import { userRepository, orderRepository } from "../domain/repositories";

export function setupRepositories(api: ApiClient) {
  userRepository.register(new UserRepositoryImpl(api));
  orderRepository.register(new OrderRepositoryImpl(api));
}

// application/usecase.ts
import { userRepository } from "../domain/repositories";

export async function getUserProfile(userId: string) {
  return userRepository.findById(userId);
}
```

## API

### `createResolver<T>(instance?: T | null): Resolver<T>`

Creates a new resolver for type `T`.

**Parameters:**

- `instance` - Optional initial instance to register

**Returns:**

- A `Resolver<T>` proxy with all properties of `T` plus a `register` method

**Throws:**

- `Error` if properties are accessed before `register()` is called (when no initial instance provided)

### `Resolver<T>`

```typescript
type Resolver<T extends object> = T & {
  register: (instance: T) => void;
};
```

## License

[MIT](./LICENSE)
npm package: @kyohxt/electron-toolkit-preload
Description: Toolkit for electron preload scripts.
Author: KYO
Latest version: 1.0.2

# @electron-toolkit/preload

> Easy to expose Electron APIs (ipcRenderer,webFrame,process) to renderer.

---

## Usage

### Install

```sh
npm i @electron-toolkit/preload
```

### Get Started

First, use `contextBridge` APIs to expose Electron APIs to renderer only if context isolation is enabled, otherwise just add to the DOM global.

```javascript
import { contextBridge } from 'electron'
import { electronAPI } from '@electron-toolkit/preload'

if (process.contextIsolated) {
  try {
    contextBridge.exposeInMainWorld('electron', electronAPI)
  } catch (error) {
    console.error(error)
  }
} else {
  window.electron = electronAPI
}
```

or

```javascript
import { electronAPI } from '@electron-toolkit/preload'

exposeElectronAPI()
```

Then, use the Electron APIs directly in the renderer process：

```javascript
// Send a message to the main process with no response
window.electron.ipcRenderer.send('electron:say', 'hello')

// Send a message to the main process with the response asynchronously
window.electron.ipcRenderer.invoke('electron:doAThing', '').then(re => {
  console.log(re)
})

// Receive messages from the main process
window.electron.ipcRenderer.on('electron:reply', (_, args) => {
  console.log(args)
})

// Remove a listener
const removeListener = window.electron.ipcRenderer.on('electron:reply', (_, args) => {})
removeListener()
```

**Note**: If you're building your Electron app with TypeScript, you may want to get TypeScript intelliSense for the renderer process. So that you can create a `*.d.ts` declaration file and globally augment the `Window` interface:

```javascript
import { ElectronAPI } from '@electron-toolkit/preload'

declare global {
  interface Window {
    electron: ElectronAPI
  }
}
```

## API

### IpcRenderer

- `send`
- `sendTo`
- `sendSync`
- `sendToHost`
- `invoke`
- `postMessage`
- `on`
- `once`
- `removeAllListeners`
- `removeListener`

### WebFrame

- `insertCSS`
- `setZoomFactor`
- `setZoomLevel`

### NodeProcess

- `platform` property
- `versions` property
- `env` property

## License

[MIT](./LICENSE) © alex.wei
npm package: @kyohxt/electron-toolkit-tsconfig
Description: A base TSConfig for working with Electron.
Author: Alex Wei
Latest version: 1.0.2

# @electron-toolkit/tsconfig

> TSConfigs for Electron projects to extend.

Requires TypeScript >= 4.5.

Install:

```sh
npm add -D @electron-toolkit/tsconfig
```

Add one of the available configurations to your `tsconfig.json`:

The base configuration:

```json
"extends": "@electron-toolkit/tsconfig/tsconfig.json"
```

Configuration for Browser environment (Renderer process):

```json
"extends": "@electron-toolkit/tsconfig/tsconfig.web.json"
```

Configuration for Node environment (Main process and Preload scripts):

```json
"extends": "@electron-toolkit/tsconfig/tsconfig.node.json"
```
npm package: @kyoko-finance/kyoko-js
Description: JavaScript library for kyoko.finance
Author: matt
Latest version: 0.0.4

# kyoko JS

## Setup

Install from npm:

`npm install @kyoko-finance/kyoko-js`

## Init
```ts
const kyokoJS = require("@kyoko-finance/kyoko-js");

const kyoko = kyokoJS.default;

(async () => {
    // 1. Dev
    await kyoko.init('JsonRpc', {url: 'http://localhost:8545/', privateKey: ''}, { chainId: 1 });
    // OR
    await kyoko.init('JsonRpc', {}, {}); // In this case JsonRpc url, privateKey, fee data and chainId will be specified automatically

    // 2. Infura
    await kyoko.init("Infura", { network: "homestead", apiKey: <INFURA_KEY> }, { chainId: 1 });
    
    // 3. Web3 provider
    await kyoko.init('Web3', { externalProvider: <WEB3_PROVIDER> }, { chainId: 1 });
    
    // get marketId
    const marketId = await kyoko.getMarketId();
    
    // get pool
    const kyokoPool = await kyoko.getKyokoPool();
})()
```
npm package: @kyomiko/koishi-plugin-before-send-transform
Description: 消息发送前通过正则匹配进行替换或者文转图
Latest version: 1.0.5

# koishi-plugin-before-send-transform

[![npm](https://img.shields.io/npm/v/koishi-plugin-before-send-transform?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-before-send-transform)

消息发送前通过正则匹配进行替换或者文转图
npm package: @kyomiko/koishi-plugin-kyomiko-middleware
Description: 自用中间件，无实际业务代码
Latest version: 1.1.7

# koishi-plugin-kyomiko-middleware

[![npm](https://img.shields.io/npm/v/koishi-plugin-kyomiko-middleware?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-kyomiko-middleware)

自用中间件，无实际业务代码
npm package: @kyon45/subscriptable
Description: A decorator library makes ESNext Class subscriptable.
Author: kyon45
Latest version: 0.1.6

> A decorator library makes ESNext Class subscriptable.

## Installation

```
npm install @kyon45/subscriptable
```

or

```
yarn add @kyon45/subscriptable
```

## Usage

### Decorator

```typescript
// esm
import subscriptable from '@kyon45/subscriptable';

@subscriptable('_data')
class MyData<T> {
  private _data: T[] = [];

  push(...values: T[]): void {
    this._data.push(...values);
  }
}

const d = new MyData<number>();
d[0]   // undefined
d.push(0, 1, 2);
d[0]   // 0
d[1]   // 1
d[2]   // 2
```

### Trap

```typescript
// esm
import { trap as subscriptable } from '@kyon45/subscriptable';
// or
import subscriptable from '@kyon45/subscriptable/lib/trap';

class MyData<T> {
  private _data: T[] = [];

  push(...values: T[]): void {
    this._data.push(...values);
  }
}

const MyDataProxied = subscriptable(MyData, '_data');

const d = new MyDataProxied<number>();
d[0]   // undefined
d.push(0, 1, 2);
d[0]   // 0
d[1]   // 1
d[2]   // 2
```

### Something like `__getitem__` ?

If you do not pass a prop (`'_data'` in the above examples), you can choose to define an `at` method, somehow like `__getitem__` in Python.

```typescript
// esm
import subscriptable from '@kyon45/subscriptable';

@subscriptable()
class MyData {
  private _data: string;

  constructor(data: string) {
    this._data = data;
  }

  at(index: number): string {
    return this._data.substr(index, 1);
  }
}

const d = new MyData('subscriptable');
d[0]    // 's'
d[2]    // 'b'
d[-1]   // 'e'
```

## TODO

- [ ] setter
- [ ] slice, like `data[0:1]`?
- [ ] iterable?
- [ ] * Pull Request welcome

## LICENSE

MIT