open-index/open-npm huggingface dataset:
npm package: @kn123/test
Description: Made with create-react-library
Latest version: 1.3.0

# test

> Made with create-react-library

[![NPM](https://img.shields.io/npm/v/test.svg)](https://www.npmjs.com/package/test) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

## Install

```bash
npm install --save test
```

## Usage

```tsx
import React, { Component } from 'react'

import MyComponent from 'test'
import 'test/dist/index.css'

class Example extends Component {
  render() {
    return <MyComponent />
  }
}
```

## License

MIT © [](https://github.com/)
npm package: @kn1ght/math-parser
Description: Parses math expressions using shunting yard algorithm
Author: kn1ght
Latest version: 0.0.5

# math-parser

Parses math expressions using shunting yard algorithm

- works with basic math operators (+, -, \*, /, %)
- supports any custom functions (should provide map for function arguments quantity and map for functions)
- supports unary minuses
- supports dynamic variables (should provide map for their values)
- supports parenthesis `(2 + 2) * 3`

### Math-parser can:

1. evaluate math expressions
2. convert math expressions to reverse polish notation (RPN)
3. convert math expressions to abstract syntax tree (AST)

### Usage example:

```
npm i @kn1ght/math-parser
```

```javascript
import { MathExprParser } from '@kn1ght/math-parser';

// provide map of function names to function implementations (if you want to use your functions)
const nameToFunctionMap = {
  pow: Math.pow,
  min: Math.min,
  max: Math.max,
};

// provide map of functions names to function argument quantity (if you want to use your functions)
const nameToArgumentsQuantityMap = {
  pow: 2,
  min: 2,
  max: 2,
};

// provide map of vaiable names to their values (if you want to use variables)
const variablesMap = {
  x: 1,
  y: 2,
};

// initialize parser by creating an instance of MathExprParser
const mathExprParser = new MathExprParser({
  nameToFunctionMap,
  nameToArgumentsQuantityMap,
  variablesMap,
});

// parses imput string expression
mathExprParser.parse('pow(2, 3) * (max([x], 2) + pow(min(3, 5), [y]))');
// get tokens (lexems) - this can be used for debugging purposes
const tokens = mathExprParser.getTokens();
// gets RPN presentation of math expression: 2 3 pow x 2 max 3 5 min y pow + *
const rpn = mathExprParser.getRPN();
// gets AST presentation of math expression
const ast = mathExprParser.getAST();
// evaluates math expression
const calculatedExpr = mathExprParser.evaluate();
// get array of errors
const errors = mathExprParser.getErrors();
```

## TODO:

1. Support dynamic parameters for functions?
2. Unary operators
3. Bitwise operators
4. Relational operators
5. Support of boolean tokens?
npm package: @knacklabs/ukti-voice-widget
Description: A clean, embeddable voice agent widget for web applications
Author: glorified0561
Latest version: 1.0.15

# 🌐 UKTI Widget

## ✨ Features

- **Beautiful Design**: Modern UI with smooth animations and hover effects
- **Responsive**: Works perfectly on desktop, tablet, and mobile devices
- **Multiple Sections**: Services, Contact information, and Resources
- **Easy Integration**: Single line of code to add to any website
- **CDN Ready**: Optimized for CDN hosting and fast loading
- **Lightweight**: Minimal impact on website performance
- **Customizable**: Easy to modify colors, content, and behavior

## 🚀 Quick Start

Add these two lines to your HTML:

```html
<link rel="stylesheet" href="https://your-cdn.com/ukti-widget.css">
<script src="https://your-cdn.com/ukti-widget.js"></script>
<script>
    initUKTIWidget({ agentId: 'your-agent-id' });
</script>
```

Or initialize manually in your JavaScript:

```javascript
initUKTIWidget({ agentId: 'your-agent-id' });
```

## 🛠️ Development

### Prerequisites

- Node.js (v16 or higher)
- npm or yarn

### Setup

```bash
# Install dependencies
npm install

# Start development server
npm run dev

# Build for production
npm run build:all
```

### Build Commands

- `npm run dev` - Start development server
- `npm run build` - Build widget for CDN hosting (produces only 2 files)
- `npm run preview` - Preview widget build

## 📁 Project Structure

```
ukti-widget/
├── src/
│   ├── components/
│   │   └── UKTIWidget.jsx      # Main widget component
│   ├── widget.jsx              # Widget entry point for CDN
│   └── index.css               # Tailwind CSS
├── vite.widget.config.js       # Widget-specific build config
└── dist-widget/                # Widget build output (after build)
    ├── ukti-widget.js          # Main widget file
    └── ukti-widget.css         # Widget styles
```

## 🌐 CDN Deployment

1. Build the widget:
   ```bash
   npm run build
   ```

2. Upload files from `dist-widget/` to your CDN:
   - `ukti-widget.js` - Main widget JavaScript (200KB)
   - `ukti-widget.css` - Widget styles (24KB)

3. Use the widget on your website:
   ```html
   <link rel="stylesheet" href="https://your-cdn.com/ukti-widget.css">
   <script src="https://your-cdn.com/ukti-widget.js"></script>
   <script>
       initUKTIWidget({ agentId: 'your-agent-id' });
   </script>
   ```

## 🎨 Customization

### Styling

The widget uses Tailwind CSS for styling. You can customize:

- Colors: Modify the gradient and color classes in `UKTIWidget.jsx`
- Animations: Adjust transition classes and hover effects
- Layout: Change grid layouts and spacing
- Typography: Update font sizes and weights

### Content

Update the widget content in `src/components/UKTIWidget.jsx`:

- Contact information
- Service descriptions
- Resource links
- Company branding

### Configuration

The widget accepts options during initialization:

```javascript
initUKTIWidget({
    // Custom options can be added here
    theme: 'light',
    position: 'bottom-right',
    // etc.
});
```
npm package: @knadh/autocomp
Description: A tiny, zero-dependency, autocomplete / autosuggestion library.
Author: Kailash Nadh
Latest version: 1.2.0

# autocomp.js

A super tiny Javascript autocomplete / autosuggestion library. Zero dependencies and ~800 bytes minified + gzipped.

[**View demo**](https://knadh.github.io/autocomp.js)

[![demo](https://github.com/knadh/autocomp.js/assets/547147/8bfaa03c-46a0-4e4e-a127-914120265009)](https://knadh.github.io/autocomp.js)


## Usage

### Node
```shell
npm install @knadh/autocomp
```

```javascript
import { autocomp } from @knadh/autocomp;

autocomp(document.querySelector("#q"), {
	onQuery: async (val) => {
		// fetch() or whatever that fetches/generates results.
		return ["results", "here"];
	},

	onSelect: (val, items) => {
		alert(val);
		return val;
	}
});
```

Check the [demo source](https://github.com/knadh/autocomp.js/blob/master/index.html) to see advanced usage and basic CSS styles.

### ES6 module
Check the [demo source](https://github.com/knadh/autocomp.js/blob/master/index.html) to use the lib in `<script>` directly on an HTML page.

Licensed under the MIT License.
npm package: @knadh/dragmove
Description: A tiny, zero-dependency library for making DOM elements draggable.
Author: Kailash Nadh
Latest version: 0.1.3

<a href="https://zerodha.tech"><img src="https://zerodha.tech/static/images/github-badge.svg" align="right" /></a>

# dragmove.js

A super tiny Javascript library to make DOM elements draggable and movable. Has touch screen support. Zero dependencies and 500 bytes Gzipped. [Demo here](https://knadh.github.io/dragmove.js/docs/).

## Usage

### Node
```shell
npm install @knadh/dragmove
```

```javascript
import { dragmove } from @knadh/dragmove;

// (target, handler, onStart(target, x, y), onEnd(target, x, y)).
// onStart and onEnd are optional callbacks that receive target element, and x, y coordinates.

dragmove(document.querySelector("#box"), document.querySelector("#box .drag-handle"));
```

### ES6 module
[Check this example](https://github.com/knadh/dragmove.js/blob/master/docs/index.html) to include dragmove.js as a `<script>` directly on an HTML page.

Licensed under the MIT License.
npm package: @knadh/floatype
Description: A tiny, zero-dependency, floating autocomplete / autosuggestion widget for textarea.
Author: Kailash Nadh
Latest version: 1.2.2

# floatype.js

A super tiny Javascript autocomplete / autosuggestion library for rendering floating suggestion widgets in textareas. Zero dependencies and ~1200 bytes minified + gzipped.

[**View demo**](https://knadh.github.io/floatype.js)

![demo](https://github.com/knadh/floatype.js/assets/547147/d4525e83-da4d-46a1-8ebe-203d49ed0115)


## Usage

### Node
```shell
npm install @knadh/floatype
```

```javascript
import { floatype } from @knadh/floatype;

floatype(document.querySelector("textarea"), {
	onQuery: async (val) => {
		// fetch() or whatever that fetches/generates results.
		return ["results", "here"];
	}
});
```

Check the [demo source](https://github.com/knadh/floatype.js/blob/master/docs/index.html) to see advanced usage and basic CSS styles.

### ES6 module
Check the [demo source](https://github.com/knadh/floatype.js/blob/master/docs/index.html) to use the lib in `<script>` directly on an HTML page.

> For dropdown suggestions on input boxes, see [autocomp.js](https://github.com/knadh/autocomp.js)


Licensed under the MIT License.
npm package: @knadh/highlighted-input
Description: A tiny, zero-dependency lib for highlighting keywords and tags in an input field.
Author: Kailash Nadh
Latest version: 1.1.1

# highlighted-input.js


highlighted-input.js is a super tiny, zero dependency Javascript lib that highlights specific keywords and tags in an <code>&lt;input&gt;</code> field. It is ideal for search inputs to highlight field selectors as the user types. It is ~450 bytes minified+gzipped.

[**View demo**](https://knadh.github.io/highlighted-input.js)

[![demo](https://github.com/user-attachments/assets/d26afc80-4f4e-4782-b701-138c8ed76026)](https://knadh.github.io/highlighted-input.js)


## Usage

### Node
```shell
npm install @knadh/highlighted-input
```

```javascript
import { highlightedInput } from @knadh/highlighted-input;

// Initialize the highlighter with the input element and keyword map
const input = document.getElementById("input");

// .highlighted-h1 and .highlighted-h2 highlight classes.
const h1 = "highlighted-h1";
const h2 = "highlighted-h2";

// Map of keywords to highlight and the corresponding classnames.
// Copy styles from style.css and add it to the webpage. 
const keywordMap = {
    "lang:": h1, 
    "repo:": h1, 
    "user:": h1, 
    "AND": h2,
    "OR": h2,
    "NOT": h2,
};

highlightedInput(input, keywordMap);
```

Copy the [CSS](https://github.com/knadh/highlighted-input.js/blob/master/style.css), customize it as required, and add it to the webpage.


Check the [demo source](https://github.com/knadh/highlighted-input.js/blob/master/docs/index.html) for a full example.

### ES6 module
Check the [demo source](https://github.com/knadh/highlighted-input.js/blob/master/docs/index.html) to use the lib in `<script>` directly in an HTML page.

Licensed under the MIT License.
npm package: @knadh/oat
Description:  Ultra-lightweight, zero dependency, semantic HTML/CSS/JS UI library
Author: Kailash Nadh
Latest version: 0.6.0

# Oat UI

> Semantic, minimal, zero dependencies. ~8KB CSS and JS.

Oat is an ultra-lightweight HTML + CSS, semantic UI component library with zero dependencies. No framework, build, or dev complexity. Just include the tiny CSS and JS files and you are good to go building decent looking web applications with most commonly needed components and elements.

Semantic tags and attributes are styled contextually out of the box without classes, forcing best practices, and reducing markup class pollution. A few dynamic components are WebComponents and use minimal JavaScript.

I wrote this to use in my own projects after getting sick of the ridiculous bloat, dependencies, and rug-pulls in Javascript UI/component libraries.

See live demo and docs at [**oat.ink**](https://oat.ink)

**IMPORTANT:** The lib is currently sub v1 and is likely to have breaking changes until it hits v1.

-------------

<img width="739" height="735" alt="image" src="https://github.com/user-attachments/assets/b0a2f55c-659d-4aab-922c-b13d89eeab36" />
npm package: @knadh/tinyrouter
Description: A tiny, zero-dependency lib for frontend routing and navigation on top of `window.history`.
Author: Kailash Nadh
Latest version: 1.2.0

# tinyrouter.js

A tiny, vanilla JS client-side router for single-page apps on top of the browser's `window.history` API.
No dependencies and ~950 bytes minified+gzipped. Ideal for simple vanilla JS single-page applications, using with AplineJS etc.

## Features

- Dynamic route parameters using the `{param}` syntax
- Route grouping with shared handlers
- Support for before/after handler hooks
- Automatic optional binding to `<a>` and other tags for navigation

[**View demo**](https://knadh.github.io/tinyrouter.js/demo)

## Usage

```
npm install @knadh/tinyrouter
```

### Basic

```javascript
import router from @knadh/tinyrouter;

// Create router instance.
const r = router.new({
  defaultHandler: (ctx) => console.log('Route not found', ctx.location.pathname)
});

// Register routes.
r.on('/', (ctx) => console.log(ctx));
r.on('/users/{id}', (ctx) => console.log('User profile', ctx.params.id));

// Initialize router.
r.ready();

r.navigate('/users/42', { filter: 'active' }, 'settings');
```

### Advanced

```javascript
// Route with before/handler hooks.
r.on('/posts/{id}', {
  before: (ctx) => console.log('Before post handler'),
  on: (ctx) => console.log('Post content', ctx.params.id),
  after: (ctx) => console.log('After post handler')
});

// Route group.
const admin = r.group('/admin', {
  before: (ctx) => checkAdminAuth()
});

// These routes are automatically prefixed with /admin and the before()
// callback on the group is triggered for all of them. 
admin.on('/dashboard', (ctx) => renderDashboard());
admin.on('/users/{id}', (ctx) => renderUserEditor(ctx.params.id));

// Programmatic navigation.
r.navigate('/users/42', { filter: 'active' }, 'settings');
```

See the [demo source](https://github.com/knadh/tinyrouter.js/blob/master/404.html) for a full working example.

### Link binding

Simply add the `data-route` attribute to links for automatic on-click naviation.

```html
<a href="/users/42" data-route>View User</a>
```


## API

| Method | Description |
|--------|-------------|
| `router.New(options)` | Creates a new router instance. See `_default_options{}` in the source code for options. |
| `r.on(path, handler)` | Registers a route handler |
| `r.group(prefix, handlers{})` | Creates a group of routes with a common prefix |
| `r.ready()` | Initializes the router |
| `r.navigate(path, query, hash, pushState)` | Navigates to a new route |
| `r.bind(parent)` | Binds navigate() onclick of all elements in the parent tagged with `data-route` |

Licensed under the MIT License.
npm package: @knadh/tinytabs
Description: A super tiny Javascript library for rendering tabbed UIs.
Author: Kailash Nadh
Latest version: 3.0.0

# tinytabs
tinytabs is a tiny (~750 bytes minified+gzip) Javascript tabbing library with zero dependencies. I turns HTML markup into a tabbed interface.

[View demo](https://knadh.github.io/tinytabs)

![image](https://user-images.githubusercontent.com/547147/60380775-8f1f9a00-9a68-11e9-9ab1-f88d32dd74d9.png)

## Usage

```shell
npm install @knadh/tinytabs
```

### Example
```html
<!-- Include the CSS file in <head> //-->
<link rel="stylesheet" type="text/css" href="tinytabs.css" />

<!-- Content to turn into tabbed UI //-->
<div id="mytabs">
	<section class="tab-section" id="music" data-name="Music">
		<h3>Music</h3>
		Content here
	</section>
	<section class="tab-section" id="videos" data-name="Videos">
		<h3>Videos</h3>
		Content
	</section>
</div>

<script type="module">
  import tinytabs from '@knadh/tinytabs';

  // Initialize tinytabs.
  tinytabs(document.querySelector("#mytabs"), {});
</script>
```

## Options

The second argument to `tinytabs()` is an optional configuration object.


| Option       | Description                                                                                             | Default        |
| :----------- | :------------------------------------------------------------------------------------------------------ | :------------- |
| `anchor`     | If `true`, clicking a tab updates the URL fragment (`#tab-id`) allowing direct linking and persistence. | `true`         |
| `history`    | If `true` (and `anchor` is `true`), enables browser Back/Forward button navigation between tabs.        | `true`         |
| `sectionClass` | CSS class applied to each `section` element that represents tab content.                              | `'tab-section'`|
| `tabsClass`  | CSS class applied to the tabs container.                                                                | `'tabs'`       |
| `tabClass`   | CSS class applied to each individual tab.                                                               | `'tab'`        |
| `selClass`   | CSS class applied to the currently selected tab.                                                        | `'sel'`        |
| `onClose`    | Callback function executed when a tab is closed. Receives the `id` of the closed tab.                   | `null`         |
| `onBefore`   | Callback function executed just before a tab becomes active. Receives the `id` of the tab.              | `null`         |
| `onAfter`    | Callback function executed right after a tab becomes active. Receives the `id` of the tab.              | `null`         |


MIT License.
npm package: @knagyorg/node-firebird-driver
Description: Firebird Driver Interfaces for Node.js
Author: Adriano dos Santos Fernandes
Latest version: 3.2.2

[![Build Status](https://travis-ci.com/asfernandes/node-firebird-drivers.svg?branch=master)](https://travis-ci.com/asfernandes/node-firebird-drivers)
[![npm version](https://badge.fury.io/js/node-firebird-driver.svg)](https://www.npmjs.com/package/node-firebird-driver)

# Firebird client interfaces for Node.js / TypeScript

This project currently has only TypeScript interfaces for a Firebird client. In the future it may have common code for any Firebird client,
like connection pools and utility functions.

## Native client

If you are looking to use Firebird from a Node.js application or library, look at:

https://github.com/asfernandes/node-firebird-drivers/tree/master/packages/node-firebird-driver-native / https://www.npmjs.com/package/node-firebird-driver-native

There is also plan to create a socket-based (pure Node.js) driver.

## Installation

```sh
yarn add node-firebird-driver
```

# Donation

If this project help you reduce time to develop, you can show your appreciation with a donation.

- GitHub Sponsor: https://github.com/sponsors/asfernandes
- Pix (Brazil): 278dd4e5-8226-494d-93a9-f3fb8a027a99
- BTC: 1Q1W3tLD1xbk81kTeFqobiyrEXcKN1GfHG
- [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=X3JMTGW92LQEL)
npm package: @knagyorg/node-firebird-driver-native
Description: Firebird Native Driver for Node.js
Author: Adriano dos Santos Fernandes
Latest version: 3.2.2

[![Build Status](https://travis-ci.com/asfernandes/node-firebird-drivers.svg?branch=master)](https://travis-ci.com/asfernandes/node-firebird-drivers)
[![npm version](https://badge.fury.io/js/node-firebird-driver-native.svg)](https://www.npmjs.com/package/node-firebird-driver-native)

# Firebird high-level native client for Node.js / TypeScript

`node-firebird-driver-native` is a modern (Firebird 3+ client, Node.js 18+, TypeScript) native client for Firebird based in the
`node-firebird-driver` API.

## Installation

```sh
yarn add node-firebird-driver-native
```

## Usage example

```ts
import { createNativeClient, getDefaultLibraryFilename } from 'node-firebird-driver-native';


async function test() {
	const client = createNativeClient(getDefaultLibraryFilename());

	const attachment = await client.createDatabase('/tmp/new-db.fdb');
	const transaction = await attachment.startTransaction();

	await attachment.execute(transaction, 'create table t1 (n integer, d date)');
	await transaction.commitRetaining();

	const statement1 = await attachment.prepare(transaction, 'insert into t1 values (?, ?)');
	await statement1.execute(transaction, [1, new Date()]);
	await statement1.execute(transaction, [2, new Date()]);
	await statement1.execute(transaction, [3, new Date()]);
	await statement1.dispose();

	const resultSet = await attachment.executeQuery(transaction, 'select n, d from t1 where n <= ?', [2]);
	const rows = await resultSet.fetch();

	for (const columns of rows)
		console.log(`n: ${columns[0]}, d: ${columns[1]}`);

	await resultSet.close();

	await transaction.commit();
	await attachment.dropDatabase();

	await client.dispose();
}

test().then(() => console.log('Finish...'));
```

See more examples in [packages/node-firebird-driver/src/test](https://github.com/asfernandes/node-firebird-drivers/tree/master/packages/node-firebird-driver/src/test) directory.

# Donation

If this project help you reduce time to develop, you can show your appreciation with a donation.

- GitHub Sponsor: https://github.com/sponsors/asfernandes
- Pix (Brazil): 278dd4e5-8226-494d-93a9-f3fb8a027a99
- BTC: 1Q1W3tLD1xbk81kTeFqobiyrEXcKN1GfHG
- [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=X3JMTGW92LQEL)
npm package: @knagyorg/node-firebird-native-api
Description: Firebird native API for Node.js
Author: Adriano dos Santos Fernandes
Latest version: 3.1.2

[![Build Status](https://travis-ci.com/asfernandes/node-firebird-drivers.svg?branch=master)](https://travis-ci.com/asfernandes/node-firebird-drivers)
[![npm version](https://badge.fury.io/js/node-firebird-native-api.svg)](https://www.npmjs.com/package/node-firebird-native-api)

# Firebird low-level API for Node.js / TypeScript

This project maps the Firebird low-level OO-API to Node.js and it's not recommended to be used directly.

## High-level native client

If you are looking to use Firebird from a Node.js application or library, look at:

https://github.com/asfernandes/node-firebird-drivers/tree/master/packages/node-firebird-driver-native / https://www.npmjs.com/package/node-firebird-driver-native

## Installation

```sh
yarn add node-firebird-native-api
```

# Donation

If this project help you reduce time to develop, you can show your appreciation with a donation.

- GitHub Sponsor: https://github.com/sponsors/asfernandes
- Pix (Brazil): 278dd4e5-8226-494d-93a9-f3fb8a027a99
- BTC: 1Q1W3tLD1xbk81kTeFqobiyrEXcKN1GfHG
- [![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=X3JMTGW92LQEL)
npm package: @knagyorg/ttlock-api
Description: TTLock API
Latest version: 0.0.20

# TTLock API

## Installation

- Run ```npm install``` after cloning the repository
- Run ```npm run build``` to build this package
- Install the package from your another project, run ```npm i <path-to-this-package-folder>```

## Usage

- Create Client

```
import { createClient } from 'ttlock-api'

const client = createClient({
  baseUrl: '',
  clientId: '',
  clientSecret: ''
})
```

- Use The APIs, one for example

```
client.lock.init({
  accessToken: '',
  date: 0,
  lockData: ''
}).then(response => {

  // Do something after getting the response
  
})
```

- You can also import the types when you need to

```
import { UserType } from 'ttlock-api'
```