open-index/open-npm huggingface dataset:
npm package: @lowlighter/remark-ruby
Description: Custom syntax for remarkjs, adding ruby (furigana) to markdown.
Author: LaySent
Latest version: 0.4.0

# remark-ruby

This [remark][remark] plugin parses custom Markdown syntax to produce (HTML) ruby.

It introduces a new [MDAST][mdast] node type: "ruby".

```javascript
interface ruby <: Node {
  type: "ruby";
  base: string;
  text: string;
  data: {
    hName: "ruby";
    hChildren: [
      {
        type: 'text',
        value: string,
      },
      {
        type: 'element',
        children: [
          { type: 'text', value: string }
        ],
        tagName: 'rp',
      },
      {
        type: 'element',
        children: [
          { type: 'text', value: string }
        ],
        tagName: 'rt',
      },
      {
        type: 'element',
        children: [
          { type: 'text', value: string },
        ],
        tagName: 'rp',
      }
    ],
  },
}
```

## Syntax

Ruby is defined in the following way:

```markdown
This plugin works on {Markdown AST}^(MDAST).
```

This would compile to the following HTML:

```html
<p>This plugin works on <ruby>Markdown AST<rp>(</rp><rt>MDAST</rt><rp>)</rp></p>
```

### Text Delimitation

You could also use `[]` to delimit text:

```markdown
{[紳][士]}^([へん][たい])
```

This would compile to the following HTML:

```html
<p><ruby><rb>紳</rb><rb>士</rb><rp>(</rp><rt>へん</rt><rt>たい</rt><rp>)</rp></ruby></p>
```

Notice that this requires the usage of `rb` tag, which is not supported by most of the browsers
except Firefox. Check [caniuse](https://caniuse.com/#search=ruby) for details.

## Installation

[npm][npm]:

```bash
npm install remark-ruby
```

## Usage

Dependencies:

```javascript
const unified = require('unified')
const remarkParse = require('remark-parse')
const remarkRuby = require('remark-ruby')
const stringify = require('rehype-stringify')
const remark2rehype = require('remark-rehype')

```

Usage:

```javascript
unified()
  .use(remarkParse)
  .use(remarkRuby)
  .use(remark2rehype)
  .use(stringify)
```

## Options

### options.parenthesis

Ruby fallback parenthesis which will be used in `rp` tag. It should be a string with at most two characters. The first will be used as left parenthesis, the last will be used as right parenthesis.

By default, it's value is `()`.

**example**

```javascript
.use(remarkAbbr, { parenthesis: '「」' })
```

**given**

```markdown
This plugin works on {Markdown AST}^(MDAST).
```

**produces**

```html
<p>This plugin works on <ruby>Markdown AST<rp>「</rp><rt>MDAST</rt><rp>」</rp></p>
```

## License

[MIT][license] © [LaySent][homepage]

<!-- Definitions -->

[license]: https://github.com/laysent/remark-ruby/blob/master/LICENSE

[homepage]: https://github.com/laysent

[npm]: https://www.npmjs.com/package/remark-ruby

[mdast]: https://github.com/syntax-tree/mdast/blob/master/readme.md

[remark]: https://github.com/remarkjs/remark
npm package: @lowlighter/run
Description: Utilities to run subprocess.
Author: lowlighter
Latest version: 3.0.0

# ⏯️ Run subprocesses

[![JSR](https://jsr.io/badges/@libs/run)](https://jsr.io/@libs/run) [![JSR Score](https://jsr.io/badges/@libs/run/score)](https://jsr.io/@libs/run)
[![NPM](https://img.shields.io/npm/v/@lowlighter%2Frun?logo=npm&labelColor=cb0000&color=183e4e)](https://www.npmjs.com/package/@lowlighter/run) [![Coverage](https://libs-coverage.lecoq.io/run/badge.svg)](https://libs-coverage.lecoq.io/run)

- [`🦕 Playground`](https://libs.lecoq.io/run)
- [`📚 Documentation`](https://jsr.io/@libs/run/doc)

> [!WARNING]
> Deno exclusive!

## 📑 Examples

### Run a command

```ts
import { command } from "./command.ts"

// Commands are run asynchronously, and support Deno.command options alongside additional options
// For example, stdio can also be set to a Logger level too or you can automatically append an extension when running on Windows
await command("deno", ["version"], { stdout: "debug", stderr: "piped", winext: ".exe" })

// Commands can be run synchronously too, and can also throw an error automatically when the process exits with a non-zero code
command("deno", ["version"], { sync: true, throw: true })
```

### Writing to stdin

```ts
import { command } from "./command.ts"

const { stdout } = await command("deno", ["repl"], {
  env: { NO_COLOR: "true" },
  // Passing a callback will automatically set `stdin` to `"piped"`
  // You can then write to the process using utility functions
  callback: async ({ i, stdio, write, close, wait }) => {
    if ((!stdio.stdout.includes("exit using")) || i) {
      return
    }
    await write("console.log('hello')")
    await wait(1000)
    close()
  },
})
console.assert(stdout.includes("hello"))
```

## ✨ Features

- Supports `stdin` interactivity through callbacks.
  - Make it possible to monitor `stdout` and `stderr` content and react accordingly.
- Auto-detects os and can automatically append an extension when running on Windows.
- Supports both `sync` and `async` modes in a single function.
  - Optionally decide to throw an error when the process exits with a non-zero code.
- Generates a `stdio` history that contains timestamped entries with configurable buffering

## 🕊️ Migrating from `2.x.x` to `3.x.x`

Version `3.x.x` and onwards require Deno `2.x.x` or later.

## 📜 Licenses

```plaintext
Copyright (c) Simon Lecoq <@lowlighter>. (MIT License)
https://github.com/lowlighter/libs/blob/main/LICENSE
```
npm package: @lowlighter/typing
Description: Utility types.
Author: lowlighter
Latest version: 3.1.1

# 🧰 Utility types

[![JSR](https://jsr.io/badges/@libs/typing)](https://jsr.io/@libs/typing) [![JSR Score](https://jsr.io/badges/@libs/typing/score)](https://jsr.io/@libs/typing)
[![NPM](https://img.shields.io/npm/v/@lowlighter%2Ftyping?logo=npm&labelColor=cb0000&color=183e4e)](https://www.npmjs.com/package/@lowlighter/typing) [![Coverage](https://libs-coverage.lecoq.io/typing/badge.svg)](https://libs-coverage.lecoq.io/typing)

- [`📚 Documentation`](https://jsr.io/@libs/typing/doc)

## 📑 Examples

```ts
import type { Arg, Arrayable, Nullable, Promisable } from "./types.ts"

function foo(_: unknown, args: Arrayable<string>): Promisable<Nullable<string>> {
  return Promise.resolve(null)
}

// Get the type of arguments[1] of `foo` function
type args = Arg<typeof foo, 1>
```

## ✨ Features

- `AsyncFunction`, `GeneratorFunction` and `AsyncGeneratorFunction` constructors.
- Addtional useful type utilites.

## 📜 License

```plaintext
Copyright (c) Simon Lecoq <@lowlighter>. (MIT License)
https://github.com/lowlighter/libs/blob/main/LICENSE
```
npm package: @lowloadlabs/mcpdiet-cli
Description: Local-first guardrails for MCP/agent runs (early preview).
Latest version: 0.2.0

# mcpdiet (CLI)

_Ship lean agents._

## What it is

Local-first CLI guardrails around MCP/agent runs; reduce context bloat and leave an audit trail for agent activity.

- Local-first by default
- Budgets + allowlists (planned)
- Audit logs you can export (planned)

## Install

```bash
npm i -g @lowloadlabs/mcpdiet-cli
```

## Quickstart (Windows PowerShell)

```powershell
cd C:\dev\lowload\mcpdiet
npm link
mcpdiet init
mcpdiet doctor
mcpdiet run -- node -e "console.log('hello')"
mcpdiet status
```

- `mcpdiet init` creates `.mcpdiet.json`, `.mcpdiet/`, `.mcpdiet/runs/`, `.mcpdiet/policies/` and the default policy files when missing.
- Migration note: if you have an older `.mcpdiet.json` without `schemaVersion`, `mcpdiet init` will add `"schemaVersion": 1` in-place without removing your other keys.

## Commands

- `mcpdiet --help` / `mcpdiet --version`
- `mcpdiet init`: initialize config and policy files; migrates existing config to `schemaVersion: 1` if missing.
- `mcpdiet doctor`: check Node version, write access, config validity, and policy JSON files. Exit codes: 0 OK, 1 missing/invalid, 2 unexpected error.
- `mcpdiet run -- <command...>` (or `mcpdiet run <command...>`): runs the command, streams stdout/stderr to console and to `.mcpdiet/runs/<id>/stdout.log` and `stderr.log`, and writes run metadata to `.mcpdiet/runs/<id>/run.json` (id, timestamps, cwd, command, args, nodeVersion, platform, exitCode, signal).
- `mcpdiet status`: list the last 10 runs from `.mcpdiet/runs/*/run.json` (newest first) with id, start time, exit code, and command.

## Files created by `init` and `run`

- `.mcpdiet.json` (schemaVersion: 1, projectName, createdAt, paths)
- `.mcpdiet/`
  - `runs/<id>/run.json`, `stdout.log`, `stderr.log`
  - `policies/allowlist.json`, `budgets.json`, `redactions.json`

## Links

- npm: https://www.npmjs.com/package/@lowloadlabs/mcpdiet-cli
- GitHub: https://github.com/Jrjoseph831/mcpdiet

## License

MIT
npm package: @lowlysre/icd-10-cm
Description: ICD-10-CM (Clinical Modification) data for use in the US healthcare system
Author: John McCall
Latest version: 1.0.1

# icd-10-cm

![NPM Version](https://img.shields.io/npm/v/%40lowlysre%2Ficd-10-cm)
[![Test](https://github.com/lowlysre/icd-10-cm/actions/workflows/test.yml/badge.svg)](https://github.com/lowlysre/icd-10-cm/actions/workflows/test.yml)
[![sustainable-npm](https://img.shields.io/badge/sustainable--npm-🌱-blue?style=flat)](https://github.com/lowlysre/sustainable-npm)


A data package containing the latest ICD-10 CM codes and descriptions, types included!

* ⚡ Fast, lookups via dictionary of minified json
* 🔒 Secure, a zero dependency package with provenance
* ⚛️ Small, limited to CM (Clinical Modification) data and less than 1MB compressed


## Install

```shell
npm install @lowlysre/icd-10-cm
```

## Usage

```ts
import getICD10Description, { normalizeICD10Code } from "@lowlysre/icd-10-cm";

// Lookups normalize dots, casing, and whitespace automatically
const description = getICD10Description("A00.0");
// "Cholera due to Vibrio cholerae 01, biovar cholerae"

// Handle missing codes by checking for undefined
const maybeDescription = getICD10Description("Z999");
if (!maybeDescription) {
	// fallback logic here
}

// You can normalize a code explicitly if you store normalized keys elsewhere
const normalized = normalizeICD10Code(" a00.1 "); // "A001"
```

## Data Source

[www.cdc.gov/nchs](https://www.cdc.gov/nchs/icd/icd-10-cm/files.html)

## Versions

* v1.0.0 - Normalized lookups, data load guard, bundled ESM/CJS build, flat ESLint 9 config, 100% tests/coverage
* v0.x.x - April 1, 2024, ICD-10-CM update
npm package: @lowmst/markdown-it-typst-math
Description: Markdown It plugin that adds Typst math equation rendering
Author: lowmst
Latest version: 1.1.0

# Markdown-It Typst Math

Markdown It plugin that adds [Typst](https://github.com/typst/typst) rendering for math equations.

It references some of the code from [vscode-markdown-it-katex](https://github.com/microsoft/vscode-markdown-it-katex) and [@myriaddreamin/reyhpe-typst](https://www.npmjs.com/package/@myriaddreamin/rehype-typst).

Adapted for VitePress dark mode.
## Usage

Install markdown-it

```bash
npm install markdown-it
```

Install the plugin

```bash
npm install @lowmst/markdown-it-typst-math
```

Use it in your javascript

```javascript
import markdownit from 'markdown-it';
import mt from '@lowmst/markdown-it-typst-math';

const md = markdownit();
md.use(mt);
```

Import CSS `'@lowmst/markdown-it-typst-math/dist/index.css'`

## Example

```markdown
# Typst Test

- Inline $integral_a^b f(x)upright(d)x=lim_(lambda->0)sum_(i=1)^n f(xi_i)Delta x_i$

- Block $$integral_a^b f(x)upright(d)x=lim_(lambda->0)sum_(i=1)^n f(xi_i)Delta x_i$$
```

![image](https://raw.githubusercontent.com/Lowmst/markdown-it-typst-math/master/image/example.png)
npm package: @lownoise-studio/rendershield
Description: Boring bot-aware prerendering: real HTML for bots, SPA for humans.
Latest version: 0.3.1

# RenderShield

RenderShield ensures crawlers receive complete, static HTML instead of an empty
JavaScript shell — without changing how humans experience your app.

It prerenders content ahead of time and can route crawler requests to that output
at the edge, while normal users continue to receive the SPA.

No frameworks required.  
No vendor lock-in.  
No guessing what bots see.

If a page builds, the HTML is complete. If it isn’t, the build fails.

---

## What problem this solves

Many modern apps technically work but are invisible to:

- search engines
- social preview scrapers
- AI crawlers

The content exists only after JavaScript executes.
Crawlers do not wait.

RenderShield fixes this by generating static, bot-readable HTML and refusing
to ship incomplete output.

---

## What RenderShield does

- Converts structured content into full static HTML pages
- Injects:
  - title
  - meta description
  - canonical link
  - Open Graph tags
  - Twitter tags
  - JSON-LD (Article)
- Generates:
  - index.html per route
  - sitemap.xml
  - robots.txt
  - optional Cloudflare Worker
- Validates output
  - missing title, metadata, or content causes the build to fail

If it builds, crawlers will see real content.

---

## What it does not do

- It does not run your application
- It does not execute JavaScript for bots
- It does not guess content
- It does not promise rankings, traffic, or citations
- It does not replace your SPA

It guarantees one thing only:
that crawlers receive complete HTML.

---

## Quickstart

1) Install dependencies

Run:

npm install

2) Initialize RenderShield

Run:

npm run build

This creates:
- rendershield.config.json
- sample content
- a prerender output directory

3) Add content

Place structured content under:

content/

4) Build prerendered output

Run:

node dist/cli.js build

Output is written to:

dist-prerender/

5) Verify output

Run:

node dist/cli.js verify

This prints curl commands you can use to confirm crawler behavior.

**Production check:** After deploying the Worker, run:

`rendershield verify --prod https://your-domain.com`

This fetches the URL as a bot and asserts the response has `x-rendershield: bot-hit` (proving the Worker served prerendered HTML). If the header is missing or `bot-fallback`, the command fails.

---

## Deployment

RenderShield is designed to run behind Cloudflare.

A Worker routes crawler requests to prerendered HTML while passing all other
traffic through unchanged.

See:
docs/deploy-cloudflare.md

---

## Philosophy

RenderShield is intentionally boring.

It does not attempt to outsmart crawlers or simulate browsers.
It produces correct HTML and refuses to ship broken output.

If crawlers cannot read it, the build fails.

---

## License

MIT License