open-index/open-npm huggingface dataset:
npm package: @immerspiele/blone
Description: A lightweight templating engine for JavaScript and TypeScript.
Latest version: 0.5.0

# Blone
Blone is a **lightweight, tree-shakeable** string templating library for JavaScript and TypeScript. Designed with minimal client-side footprint in mind, Blone provides a simple yet powerful way to create dynamic strings through template strings with variable interpolation and filtering capabilities.

## Features
- **Lightweight**: Zero runtime dependencies and minimal bundle size.
- **Tree-shakeable**: Only include the parts of the library you use.
- **Easy to use**: Simple API for parsing and rendering templates.
- **Filter support**: Built-in filters for common string manipulations, with the ability to add custom filters.
- **TypeScript support**: Fully typed for better developer experience.

## Installation
You can install Blone via npm:

```bash
npm install @immerspiele/blone
```

or via yarn:

```bash
yarn add @immerspiele/blone
```

## Usage
Here's a basic example of how to use Blone:
```javascript
import { parse, render } from '@immerspiele/blone';
import * as filters from '@immerspiele/blone/filters';

const template = parse('Hello, {name|uppercase}!');
const result = render(template, { name: 'world' }, [{ ...filters }]);
console.log(result); // Hello, WORLD!
```
npm package: @immerspiele/boom
Description: ![header](https://github.com/user-attachments/assets/1672d691-f618-44c8-b6dd-7c9bcdf0565d)
Latest version: 0.1.3

![header](https://github.com/user-attachments/assets/1672d691-f618-44c8-b6dd-7c9bcdf0565d)

# boom 💥

> Tools we use to build puzzles.

## Installation

With `npm`

```bash
npm install @immerspiele/boom
```

or with `yarn`

```bash
yarn add @immerspiele/boom
```

## Packages

### Signal

A simple signal implementation.

### Screen

Screen controller. Manage screen transitions and screen states.

#### Setup

```typescript
import { initialize } from '@immerspiele/boom/screen';

// Tell the screen controller which "container" element to render the screens in.
initialize(document.getElementById('screen-container'));
```

#### Usage

```typescript
import { createScreen, onMount, onUnmount } from '@immerspiele/boom/screen';

const screen = createScreen(() => {
  const $ = document.createElement('div');

  onMount(() => {
    // Do something when the screen is mounted.
  });

  onUnmount(() => {
    // Do something right before the screen is unmounted.
  });

  return $;
});
npm package: @immerspiele/dimmer
Description: Small, lightweight library for creating DOM elements in pure JavaScript.
Latest version: 2.0.1

<img width="1010" height="408" alt="logo" src="https://github.com/user-attachments/assets/b5d88c2d-148a-4fff-bd9b-929f3307feb2" />

[![Version](https://img.shields.io/npm/v/@immerspiele/dimmer.svg)](https://www.npmjs.com/package/@immerspiele/dimmer)
[![CI](https://github.com/immerspiele/dimmer/actions/workflows/ci.yml/badge.svg)](https://github.com/immerspiele/dimmer/actions/workflows/ci.yml)
[![gzip size](http://img.badgesize.io/https://unpkg.com/@immerspiele/dimmer@latest/dist/index.mjs?compression=gzip)](https://unpkg.com/@immerspiele/dimmer@latest/dist/index.mjs)

**Dimmer** is a small, lightweight library for creating DOM elements in pure JavaScript. It’s designed to be fast, convenient, and dependency-free, making it easy to build and manipulate HTML without bulky frameworks.

## Installation

```bash
# Using npm
npm install @immerspiele/dimmer

# Using yarn
yarn add @immerspiele/dimmer
```

## Quick Start

```typescript
import { div, h2, p, appendChildren } from '@immerspiele/dimmer';

const $container = div('container', [
  h2('title', 'Welcome to Dimmer'),
  p(null, 'This is a simple example of using Dimmer to create DOM elements.'),
]);

appendChildren(document.body, $container);
```
npm package: @immersus-machina/json-tag
Description: Cross-language JSON type tagging using #type
Author: immersus-machina
Latest version: 0.1.7

# json-tag

TypeScript support for [JSON#](https://www.github.com/immersus-machina/json-tag).

Utility types and runtime helpers for the JSON# convention.

## Install

```bash
npm install @immersus-machina/json-tag
```

## Usage

Define your types:

```ts
import type { JsonTagged } from "@immersus-machina/json-tag";

type Circle = JsonTagged<"Circle", { radius: number }>;
type Rectangle = JsonTagged<"Rectangle", { width: number; height: number }>;
type Shape = Circle | Rectangle;
```

Narrow with type safety:

```ts
import { hasJsonTag } from "@immersus-machina/json-tag";

const shape = JSON.parse(json) as Shape;

if (hasJsonTag(shape, "Circle")) {
  shape.radius; // compiler knows this exists
}
```

Create tagged objects:

```ts
import { toJsonTag } from "@immersus-machina/json-tag";

const circle = toJsonTag("Circle", { radius: 4 });
// { "#type": "Circle", radius: 4 }
```

## API

| Export | Kind | Description |
|---|---|---|
| `JsonTagged<Tag, Fields>` | type | Tagged object type |
| `JsonTagOf<T>` | type | Extract tag from type |
| `JsonTagVariant<Union, Tag>` | type | Narrow union to variant |
| `hasJsonTag(value, tag)` | function | Type predicate — narrows to variant |
| `isJsonTagged(value)` | function | Type guard — checks for `#type` string |
| `jsonTagOf(value)` | function | Extract `#type` value or `undefined` |
| `toJsonTag(tag, fields)` | function | Create tagged object |
| `TYPE_FIELD` | const | `"#type"` |

## Zero dependencies

No runtime dependencies.
npm package: @immfly/js-bash-kit
Description: bash utils kit
Author: Albert Pérez Farrés
Latest version: 1.0.5

![npm](https://img.shields.io/npm/v/@immfly/js-bash-kit.svg) [![Build Status](https://travis-ci.org/sonofjavascript/js-bash-kit.svg?branch=master)](https://travis-ci.org/sonofjavascript/js-bash-kit) [![MIT license](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)

# js-bash-kit
This package exports modules used through `js` immfly projects.

## Shell
Allows to run bash commands.
```js
const { Shell } = require('@immfly/js-bash-kit' )

...
await Shell.execute('echo "Hellow"')
```

## FileWriter
Allows to write files given the output file and its content.
```js
const { FileWriter } = require('@immfly/js-bash-kit' )

...
await FileWriter.write('file.txt', '::content::'))
```

## EnvFiler
Allows generate `.env` files given the output file and the data to generate.
```js
const { EnvFiler } = require('@immfly/js-bash-kit' )

...
await EnvFiler.build({
  file: 'file.txt',
  data1: '::data1::',
  data2: '::data2::'
})
```

The result of this example whould be a file named `file.txt` with this content:
```bash
DATA1=::data1
DATA2=::data2
```


## Contributing
Contributions welcome; Please submit all pull requests the against master branch. If your pull request contains JavaScript patches or features, you should include relevant unit tests. Please check the [Contributing Guidelines](contributng.md) for more details. Thanks!

## Author
Albert Pérez Farrés 

## License
 - **MIT** : http://opensource.org/licenses/MIT
npm package: @immfly/js-tool-kit
Description: Javascript tool kit
Author: Albert Pérez Farrés
Latest version: 1.0.0

![npm](https://img.shields.io/npm/v/@immfly/js-tool-kit.svg) [![Build Status](https://travis-ci.org/immfly/js-tool-kit.svg?branch=master)](https://travis-ci.org/immfly/js-tool-kit) [![MIT license](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)

# js-tool-kit
<img src='https://lh3.googleusercontent.com/proxy/ePay-1VRq51XVxc-8gEttC4p8AZ22Vn-Dq4YpwnnoDba6PboVWyIYGMLOZJ1f6GohNJSnkZx5BNradpSem_LPcTH9x9z7u29vwEx1M216i1chviNeA' />

This package exports modules used through `js` immfly projects.

## Installation
```
npm install --save-dev @immfly/js-tool-kit
```

## tool

### Shell
Allows to run bash commands.
```js
const { Shell } = require('@immfly/js-tool-kit' )

...
await Shell.execute('echo "Hellow"')
```

### FileWriter
Allows to write files given the output file and its content.
```js
const { FileWriter } = require('@immfly/js-tool-kit' )

...
await FileWriter.write('file.txt', '::content::'))
```

### EnvFiler
Allows generate `.env` files given the output file and the data to generate.
```js
const { EnvFiler } = require('@immfly/js-tool-kit' )

...
await EnvFiler.build({
  file: 'file.txt',
  data1: '::data1::',
  data2: '::data2::'
})
```

The result of this example whould be a file named `file.txt` with this content:
```bash
DATA1=::data1
DATA2=::data2

```


## Contributing
Contributions welcome; Please submit all pull requests the against master branch. If your pull request contains JavaScript patches or features, you should include relevant unit tests. Please check the [Contributing Guidelines](contributng.md) for more details. Thanks!

## Author
Albert Pérez Farrés 

## License
 - **MIT** : http://opensource.org/licenses/MIT
npm package: @immfly/js-toolkit
Description: Javascript tool kit
Author: Albert Pérez Farrés
Latest version: 1.0.0

![npm](https://img.shields.io/npm/v/@immfly/js-toolkit.svg) [![Build Status](https://travis-ci.org/immfly/js-toolkit.svg?branch=master)](https://travis-ci.org/immfly/js-toolkit) [![MIT license](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)

# js-toolkit
<img src='https://lh3.googleusercontent.com/proxy/ePay-1VRq51XVxc-8gEttC4p8AZ22Vn-Dq4YpwnnoDba6PboVWyIYGMLOZJ1f6GohNJSnkZx5BNradpSem_LPcTH9x9z7u29vwEx1M216i1chviNeA' />

This package exports modules used through `js` immfly projects.

## Installation
```
npm install --save-dev @immfly/js-toolkit
```

## tool

### Shell
Allows to run bash commands.
```js
const { Shell } = require('@immfly/js-toolkit' )

...
await Shell.execute('echo "Hellow"')
```

### FileWriter
Allows to write files given the output file and its content.
```js
const { FileWriter } = require('@immfly/js-toolkit' )

...
await FileWriter.write('file.txt', '::content::'))
```

### EnvFiler
Allows generate `.env` files given the output file and the data to generate.
```js
const { EnvFiler } = require('@immfly/js-toolkit' )

...
await EnvFiler.build({
  file: 'file.txt',
  data1: '::data1::',
  data2: '::data2::'
})
```

The result of this example whould be a file named `file.txt` with this content:
```bash
DATA1=::data1
DATA2=::data2

```


## Contributing
Contributions welcome; Please submit all pull requests the against master branch. If your pull request contains JavaScript patches or features, you should include relevant unit tests. Please check the [Contributing Guidelines](contributng.md) for more details. Thanks!

## Author
Albert Pérez Farrés 

## License
 - **MIT** : http://opensource.org/licenses/MIT
npm package: @immfly/js-tools-kit
Description: Javascript tools kit
Author: Albert Pérez Farrés
Latest version: 1.0.0

![npm](https://img.shields.io/npm/v/@immfly/js-tools-kit.svg) [![Build Status](https://travis-ci.org/immfly/js-tools-kit.svg?branch=master)](https://travis-ci.org/immfly/js-tools-kit) [![MIT license](http://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)

# js-tools-kit
<img src='https://lh3.googleusercontent.com/proxy/ePay-1VRq51XVxc-8gEttC4p8AZ22Vn-Dq4YpwnnoDba6PboVWyIYGMLOZJ1f6GohNJSnkZx5BNradpSem_LPcTH9x9z7u29vwEx1M216i1chviNeA' />

This package exports modules used through `js` immfly projects.

## Installation
```
npm install --save-dev @immfly/js-tools-kit
```

## Tools

### Shell
Allows to run bash commands.
```js
const { Shell } = require('@immfly/js-tools-kit' )

...
await Shell.execute('echo "Hellow"')
```

### FileWriter
Allows to write files given the output file and its content.
```js
const { FileWriter } = require('@immfly/js-tools-kit' )

...
await FileWriter.write('file.txt', '::content::'))
```

### EnvFiler
Allows generate `.env` files given the output file and the data to generate.
```js
const { EnvFiler } = require('@immfly/js-tools-kit' )

...
await EnvFiler.build({
  file: 'file.txt',
  data1: '::data1::',
  data2: '::data2::'
})
```

The result of this example whould be a file named `file.txt` with this content:
```bash
DATA1=::data1
DATA2=::data2

```


## Contributing
Contributions welcome; Please submit all pull requests the against master branch. If your pull request contains JavaScript patches or features, you should include relevant unit tests. Please check the [Contributing Guidelines](contributng.md) for more details. Thanks!

## Author
Albert Pérez Farrés 

## License
 - **MIT** : http://opensource.org/licenses/MIT
npm package: @immich/kysely-adapter-cloudflare
Description: A Kysely adapter for cloudflare databases
Latest version: 0.1.0

# Kysely Adapter Cloudflare

Kysely adapter for Cloudflare databases.

## Install

```bash
pnpm i @immich/kysely-adapter-cloudflare
```

## Example

```typescript
import { CloudflareD1Dialect } from '@immich/kysely-adapter-cloudflare';

const dialect = new CloudflareD1Dialect({ database: process.env.DB });

const db = new Kysely<MySchema>({ dialect });
```

## Transactions

The `CloudflareD1Dialect` implements Kysely transactions using the D1 [batch](https://developers.cloudflare.com/d1/worker-api/d1-database/#batch) method. They're not real transactions, since D1 does not support transactions in the traditional sense. In short, queries used inside a `transaction()` are _added_ to a batch and then submitted all at once when the transaction is committed.

Note: This implies that you _cannot_ use any of the return values, as there aren't any. See examples below.

### Good

```typescript
db.transaction().execute(async (tx) => {
  await tx.insertInto('post').values(item).execute();
  await tx.insertInto('article').values(item).execute();
});
```

### Bad

```typescript
const article = // will be undefined
  await db.transaction().execute(async (tx) => {
    const post = await tx.insertInto('posts').values(item).execute();
    return tx
      .insertInto('articles')
      .values({
        ...article,
        postId: post.id, // will be undefined
      })
      .execute();
  });
```
npm package: @imminent/mdx-render
Description: Convert .mdx files to standalone HTML with embedded React components
Author: Bruno Pedro
Latest version: 0.1.3

# mdx-render

Convert `.mdx` files to standalone HTML with embedded React components.

The output is a single self-contained `.html` file — no server required. Open it directly in a browser.

## Install

```bash
npm install -g @imminent/mdx-render
```

## Usage

```bash
# Basic conversion — outputs my-doc.html
mdx-render my-doc.mdx

# Specify output file
mdx-render my-doc.mdx -o dist/index.html

# Add a custom page title
mdx-render my-doc.mdx --title "My Document"

# Inline a CSS file
mdx-render my-doc.mdx --css styles.css

# Use a components config (see below)
mdx-render my-doc.mdx --config mdx-render.config.js
```

### Options

| Option | Description |
|---|---|
| `<input>` | Path to the `.mdx` file to convert |
| `-o, --output <file>` | Output HTML file path (default: `<input-name>.html`) |
| `-c, --config <file>` | Path to components config (auto-discovers `mdx-render.config.js`) |
| `--title <title>` | HTML `<title>` tag content (default: input filename) |
| `--css <file>` | Path to a CSS file to inline into the output HTML |
| `-V, --version` | Print version number |
| `-h, --help` | Print help |

## Use with npx (no install required)

```bash
npx mdx-render my-doc.mdx
```

## Custom Components

MDX files can use custom React components. To make them available during bundling, create a config file:

```js
// mdx-render.config.js
import { MyChart } from './components/MyChart.jsx'
import { CodeBlock } from './components/CodeBlock.jsx'

export const components = {
  MyChart,
  CodeBlock,
}
```

Then run:

```bash
mdx-render my-doc.mdx --config mdx-render.config.js
```

Or place `mdx-render.config.js` in the same directory where you run the command — it will be picked up automatically.

Inside your `.mdx` file, use components by name:

```mdx
# Hello

<MyChart data={[1, 2, 3]} />

Some text with a <CodeBlock lang="js">console.log('hi')</CodeBlock>
```

> **Note:** The config file and its imports are bundled using esbuild. Your components' own dependencies must be installed in a `node_modules` directory reachable from the config file. React itself is provided by `mdx-render` — you do not need React in your project.

## How it works

1. The `.mdx` file is compiled to a JavaScript ES module using `@mdx-js/mdx`.
2. The compiled module is bundled with React (included), `react-dom/client`, and any custom components using `esbuild` into a single minified IIFE script.
3. The script is embedded in a minimal HTML file alongside a `<div id="root">`.
4. When the HTML file is opened in a browser, React mounts and renders the MDX content.

## License

MIT