open-index/open-npm huggingface dataset:
npm package: @olga.n.sh/kolkov-angular-editor
Description: A simple native WYSIWYG editor for Angular 8+, 12+. Rich Text editor component for Angular.
Author: Andrey Kolkov
Latest version: 1.2.3

# Core AngularEditor

Fork of @kolkov/angular-editor modified for specific use. Please use the original repo at https://github.com/kolkov/angular-editor.

## Getting Started

### Installation

Install via [npm][npm] package manager

```bash
npm install @olga.n.sh/kolkov-angular-editor --save
```

### Versions

1.2.3 - contains fixs for blur event
npm package: @olga_spiridonova/ui-library
Description: ### The library is under development and will be supplemented with new components ### Figma: https://www.figma.com/design/txd9ZCN80qADFUreB1cQuK/Dananz?node-id=1-540&t=JGfyk7FtmRVEW4Qd-0
Latest version: 0.0.5

# UI library

### The library is under development and will be supplemented with new components
### Figma: https://www.figma.com/design/txd9ZCN80qADFUreB1cQuK/Dananz?node-id=1-540&t=JGfyk7FtmRVEW4Qd-0

Install the library: ```npm i @olga_spiridonova/ui-library```
npm package: @olhaovch/randomid-generator
Description: randomid-generator
Latest version: 1.0.1

randomid-generator

The randomid-generator package is a simple Node.js library that allows you to generate random identifiers of a specified length.

Installation
To install the random-id-generator package, execute the following command:

npm i @olhaovch/randomid-generator

Usage
Below is an example of how to use the random-id-generator package:

const randomID = require('random-id-generator');
// Generate an identifier with a length of 10
const id = randomID(10);
console.log(id); // It will display a random identifier with a length of 10
npm package: @olian/brow
Description: CLI tool for redirecting logs from the terminal into the browser.
Author: Olian04
Latest version: 3.3.0

# [brow](https://www.npmjs.com/package/@olian/brow)
CLI tool for viewing cli logs in the browser.

```
$ node helloworld.js | brow foobar
Mirroring logs at localhost:10005/?foobar
```

Navigate to `localhost:10005` and select "foobar" from the list and you will start seeing the logs from the `node index.js` process.

_(You dont have to provide your own group name, in the example above it was "foobar". If you dont provide one, the top most directory will be used as the group name. Everything piped under the same groupname will be treated as the same log as far as brow is concerned)_

## How to

1. Install brow: `npm i -g @olian/brow`
2. Spin up the brow server by running: `brow-server`, this will create a `.brow` directory in your home directory, this is where your brow config and database will live.
3. Use brow by piping anything into it: `echo Hello World | brow`

## Why

I started developing brow because I needed a tool that allowed me to collect logs from my home server in a single easy to reach place.
npm package: @olian/dice-roller
Description: Tiny Dice Rolling POC
Author: Olian04
Latest version: 2.0.0

# dice-roller

Tiny Dice Rolling POC

## Usage

Can be used in 2 different ways:

1. Install it as a node js library
2. Install it as a shell command

### Install (library)

```sh
npm i @olian/dice-roller
```

```js
const { rollDice } = require('@olian/dice-roller');

const input = '2d4 + 2 + d6';
console.log(input);
const result = rollDice(input);
console.log(result.values.join(' + '), '=', result.sum);
```

### Install (shell command)

```sh
$ sudo npm i -g @olian/dice-roller
$ roll 2d4 + 2 + d6
2d4 + 2 + d6
3 + 4 + 2 + 2 = 11
```

## Syntax

Input string can be any combination of dice including static rolls.

Ex:

* 2d6
* 3d4 + 3
* 2d10 + 4d9 + 2
* d20
* d20 d20 d20
* d3 2d5 d10 + 6
npm package: @olian/event-state
Description: A subscription based state management solution.
Author: Olian04
Latest version: 1.1.0

# event-state

A subscription based state management solution.

```ts
import { makeState } from '@olian/event-state';

const state = makeState({
    foo: 1,
    bar: {
        biz: 10,
    }
})

state.$get() // { foo: 1, bar: { biz: 10 } }
state.bar.$get() // { biz: 10 }


state.foo.$get() // 1
state.foo.$subscribe(v => console.log('Foo:', v)) // triggers once foo.$set() is called
state.foo.$set(3)
state.foo.$get() // 3


// Subscribe events will bubble up to parent listeners
state.$subscribe(v => console.log('State:', v)) // triggers if state.$set(), bar.$set() or biz.$set() is called
state.bar.$subscribe(v => console.log('State.Bar:', v)) // triggers if bar.$set() or biz.$set() is called
state.bar.biz.$subscribe(v => console.log('State.Bar.Biz:', v)) // triggers if biz.$set() is called
state.bar.biz.$set(20)

// Event bubbling can be prevented
state.bar.$subscribe(v => console.log('State.Bar:', v)) // triggers if bar.$set() is called
state.bar.biz.$subscribe((v, preventBubble) => {
  preventBubble()
  console.log('State.Bar.Biz:', v)
}) // triggers if biz.$set() is called
```

## Install

__NPM:__ [`npm i @olian/event-state`](https://www.npmjs.com/package/@olian/event-state)
npm package: @olian/github-readme
Description: A custom element that renders the readme of a github repository
Author: Olian04
Latest version: 1.3.0

# github-readme
A custom element that renders the readme of a github repository

```html
<script src="https://unpkg.com/@olian/github-readme"></script>
<github-readme
    user="olian04"
    repository="github-readme"
    ></github-readme>
```

[Click here to see this page rendered using `github-readme`](https://olian04.github.io/github-readme) :smile:

Or [click here to see a multi page demo in a jsfiddle](https://jsfiddle.net/cLyum7jr/33/)

__Help me help you:__ <a href="https://www.buymeacoffee.com/olian04" target="_blank"><img src="https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png" alt="Buy Me A Coffee" style="height: auto !important;width: auto !important;" ></a>

## Install

__NPM:__ [`npm install @olian/github-readme`](https://www.npmjs.com/package/@olian/github-readme)

__CDN:__ `<script src="https://unpkg.com/@olian/github-readme"></script>`

## Advanced

```html
<github-readme
    user="olian04"
    repository="github-readme"
    branch="master"
    index="/README.md"
    navigation="full"
    bookmarks="[License](/LICENSE);[Demo](/index.html)"
    style=""
    id=""
    class=""
    ></github-readme>
```

|property | default | description|
|:-----------:|:----------:|:--------------|
|user |  | The name of the github user that owns the repository|
|repository |  | The name of the github repository you want to display|
|branch | master | The name of the git branch you want to display|
|index | /README.md | The path to the index file.|
|navigation | full | `none` will hide the navigation bar. `history` will only show the back, forward and reload buttons. `full` will show the history navigation as well as a bookmarks row.|
|bookmarks | | Optional bookmarks provided in the form of a simecolon separated string of markdown links. `[TITLE](LINK);[TITLE](LINK);[TITLE](LINK)`|
|style |  | Optional styles passed down to the top most element of the component.|
|id |  | Optional id passed down to the top most element of the component.|
|class |  | Optional class passed down to the top most element of the component.|

_**Note:** github-readme uses unauthenticated requests to the github api and is there for limited by [its rate limiting rules](https://developer.github.com/v3/#rate-limiting)._
> For unauthenticated requests, the rate limit allows for up to 60 requests per hour. Unauthenticated requests are associated with the originating IP address, and not the user making requests.

## License

See [Licence](/LICENSE)
npm package: @olian/typescript-helpers
Description: A collection of typescript functions and structures that I usually end up needing when developing.
Author: Olian04
Latest version: 3.2.1

# typescript-helpers

A collection of typescript functions and structures that I usually end up needing when developing.

Install: [`npm i @olian/typescript-helpers`](https://www.npmjs.com/package/@olian/typescript-helpers)
npm package: @olian04/proxy_pool
Description: An object pool specifically for proxies
Author: olian04
Latest version: 1.1.2

# proxy_pool

An object pool specifically for proxies

## Installation

```bash
npm install @olian04/proxy_pool
```

## Usage

```typescript
import { ProxyPool, Proxy } from '@olian04/proxy_pool';

const pool = new ProxyPool<
  Record<string, number>,
  [ctx: { foo: number }, num: number]
>({
  set: () => false,
  get: (data, num, key) => data.foo * num,
});

const obj = pool.get({ foo: 10 }, 2);
assert(obj.foo === 20);

const obj2 = pool.get({ foo: 20 }, 4);
assert(obj2.foo === 80);

pool.release(obj);
pool.release(obj2);
```
npm package: @olian04/xs
Description: Query directories using a set of partial paths and their levenshtein distances to acutal directories
Author: Olian04
Latest version: 1.1.0

# [XS](https://www.npmjs.com/package/@olian04/xs) _(read like "excess")_
Query directories using a set of partial paths and their levenshtein distances to acutal directories

## Install: 
`npm i @olian04/xs`

## Use:
```js
const xs = require('xs');

const res = xs('2 foo rty'); 
console.log(res);
/*
{
  query: the query string passed to xs,
  distance: the distance between your query and the resulting path, smaller is better and 0 is best,
  path: absolute path,
  folders: array of all folder names at the path,
  files: array of all filenames at the path
}
*/
```

## Note
Since `xs` queries the file tree using levenshtein distances for comparisons, this means that even if there isn't a folder called `XXX` it will pick the closest match and return that one. This is true in all cases but one, if there is no folder at the desired query depth it will return undefined.
npm package: @oliasoft-open-source/eslint-config-oliasoft
Description: Oliasoft ESLint configuration
Author: Oliasoft and contributors
Latest version: 1.3.1
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# eslint-config-oliasoft

Common ESLint rules for Oliasoft projects.

# Usage

To install and use in a project:

```
npm install -D eslint @oliasoft-open-source/eslint-config-oliasoft
```

# Development

We utilize [yarn](https://yarnpkg.com/), so to install dependencies, use `yarn` command

## Deployment

To deploy changes:

- bump the version number in `package.json` (use [SemVer](https://semver.org/))
- submit and complete a merge request describing changes
- merging automatically publishes package
- import new version in dependent repositories
npm package: @oliasoft-open-source/why-render
Description: Debugging helper functions for understanding why React components are re-rendering
Author: Oliasoft AS and contributors
Latest version: 1.3.1

# Why render?

Helper functions for comparing payloads and debugging rendering issues in React components.

**Note: this package is for debugging/testing only, and should not be merged into production code**

## Installation

```bash
yarn add --D @oliasoft-open-source/why-render
```

## Compare Payloads

There is a general-purpose function `explainDifferences` which compares (diffs) two arguments and explains why they
are different. This can be used in any context, not just React-code.

```tsx
import { explainDifferences } from '@oliasoft-open-source/why-render';

explainDifferences(objectA, objectB);
```

## Debugging React Renders

There are React helper functions for debugging why components are re-rendering.

To use for function components:

```tsx
import { useWhyRender } from '@oliasoft-open-source/why-render';

const Component = (props) => {
    useWhyRender(props);
}
```

To use for class components:

```tsx
import { whyRender } from '@oliasoft-open-source/why-render';

componentDidUpdate(prevProps, prevState) {
  whyRender(prevProps, this.props, prevState, this.state);
}
```

Alternatively, there is a HOC which can be used to wrap components:

```tsx
import { withWhyRender } from '@oliasoft-open-source/why-render';

const WrappedComponent = withWhyRender(SimpleComponent);
```

## Debugging React Render times

There are also React helper functions for debugging render time.

The `useInitTime` hook measures the *init time* of a component (time before its first render, not its rendering time).

```tsx
import { useInitTime } from '@oliasoft-open-source/why-render';

const Component = (props) => {
    useInitTime();
}
```
npm package: @olib-ai/olib-ai
Description: Olib AI - JavaScript SDK (Coming Soon)
Author: Olib AI
Latest version: 0.1.0

# Olib AI JavaScript SDK

**Coming Soon!**

This package is a placeholder for the upcoming Olib AI JavaScript SDK. Stay tuned for our official release.

## About Olib AI

Olib AI is building innovative AI products to help businesses leverage artificial intelligence technologies.

## Contact

For more information, please visit [https://olib.ai](https://olib.ai) or contact us at akram@olib.ai.
npm package: @olibm/jwks-verify
Description: Verify JWT using keys from a keyserver
Author: olibm
Latest version: 2.0.0

# @olibm/jwks-verify

## Example

```
import { jwksVerify } from '@olibm/jwks-verify'

async function example() {
    const audience = 'my-project-id';
    const issuer = `https://securetoken.google.com/${audience}`;
    const keyServer = 'https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com';
    const token = '...some JWT issued by Google';
    const verifiedClaims = await jwksVerify(issuer, audience, keyServer, token)
}
```
npm package: @olibolduc/website-translator
Description: CLI tool to translate static websites using Google Gemini AI with intelligent caching and SEO optimization
Author: Oli Bolduc
Latest version: 1.0.8

# @olibolduc/website-translator

AI-powered translation tool for static websites with intelligent caching and SEO optimization.

## Features

- 🤖 **AI Translation**: Uses Google Gemini for accurate, context-aware translations
- 💾 **Smart Caching**: Stores translations in `translations.json` to avoid redundant API calls
- 🌐 **SEO Optimized**: Automatically generates `hreflang`, `canonical` tags, and `sitemap.xml`
- 🔗 **URL Management**: Translates slugs and rewrites all internal links
- 📦 **Full Build**: Generates complete multilingual site structure

## Installation

```bash
npm install @olibolduc/website-translator
```

## Usage

### Basic Command

```bash
npx website-translator translate <source-dir> <output-dir> --lang <target-lang> --url <base-url> [--source-lang <source-lang>]
```

### Example

```bash
npx website-translator translate . ./dist --lang en --url https://mysite.com --source-lang fr
```

### Parameters

- `<source-dir>`: Path to your Webflow export or static site
- `<output-dir>`: Where to generate the translated site
- `--lang`: Target language code (en, es, fr, de, etc.)
- `--url`: Base URL for canonical tags and sitemap
- `--source-lang`: (Optional) Source language code (default: fr)

## Output Structure

```
dist/
├── index.html              # Original (FR)
├── contact.html            # Original (FR)
├── sitemap.xml             # Global sitemap
├── en/                     # Translated version
│   ├── index.html
│   ├── contact-us.html
│   ├── css/
│   ├── js/
│   └── images/
```

## Environment Variables

Create a `.env` file:

```env
GEMINI_API_KEY=your_google_gemini_api_key
```

## Translation Cache

The tool maintains a `translations.json` file to:
- Avoid re-translating unchanged content
- Allow manual corrections
- Reduce API costs

### Editing Translations

1. Open `translations.json`
2. Find the text you want to change
3. Modify the `translated` field
4. Save and rebuild

## GitHub Actions Integration

Example workflow:

```yaml
- name: Install translator
  run: npm install @olibolduc/website-translator

- name: Translate site
  env:
    GEMINI_API_KEY: ${{ secrets.GEMINI_API_KEY }}
  run: npx website-translator translate ./source ./dist --lang en --url https://mysite.com
```

## License

MIT
npm package: @oliboy50/listal-exporter
Description: Extract data from a list on Listal website.
Author: Oliboy50
Latest version: 0.1.1

# listal-exporter

Leverages [jsonframe-cheerio](https://github.com/gahabeen/jsonframe-cheerio) to extract data from a list on [listal](http://www.listal.com).

## Install

```shell
npm install --save @oliboy50/listal-exporter
```

## Usage

```js
const listalExporter = require('@oliboy50/listal-exporter');

// This "html" will be passed to "cheerio.load()" function (so it can be everything cheerio can load)
const html = htmlOfTheListalListToExtractDataFrom;

// "exportList" also accept a second parameter to pass "options" to "jsonframe-cheerio"'s scrape function (such as "{string: true}" to get data as a JSON string instead of a javascript object)
const listData = listalExporter.exportList(html);
```

## Note

This package main purpose is to export the data you "own" (for instance, I don't want to use Listal anymore, so I decided to remake my [own list](http://www.listal.com/list/my-animes-list-oliboy50) elsewhere, without having to rewrite everything manually).

I mean that you should **not** use this package to extract data from every list you want on Listal... Be kind and do it only on the ones you own.
npm package: @olierjs/create
Description: Scaffold a new Node.js TypeScript project with Rust tools chain
Latest version: 0.3.1

# @olierjs/create

⚡ Scaffold a new Node.js TypeScript project with Rust tools chain

## Usage

```bash
# npm
npm create @olierjs/create my-project

# yarn
yarn create @olierjs/create my-project

# pnpm (recommended)
pnpm create @olierjs/create my-project

# bun
bun create @olierjs/create my-project

# npx
npx @olierjs/create my-project
```

## Options

```
Options:
  -h, --help       Show help
  -v, --version    Show version
  -f, --force      Force create (skip non-empty check)
  -o, --overwrite  Overwrite existing directory
  --no-git         Skip git initialization
  --no-install     Skip dependency installation
```

## Examples

```bash
# Create project with default options
pnpm create @olierjs/create my-app

# Create without git init
pnpm create @olierjs/create my-app --no-git

# Create without auto-install
pnpm create @olierjs/create my-app --no-install

# Force overwrite
pnpm create @olierjs/create my-app --overwrite
```

## Template Features

- **TypeScript Go** - Rust-rewritten TypeScript compiler
- **RSLint** - High-performance linter in Rust
- **Oxc** - Rust-based JavaScript toolchain
- **RSTest** - Testing framework powered by Rspack
- **pnpm** - Fast, disk space efficient package manager
- **Dual Runtime** - Node.js + Bun support

## Development

```bash
# Clone the repo
git clone https://github.com/TbhT/mini-repo.git
cd mini-repo

# Install dependencies
pnpm install

# Link for local testing
pnpm link --global

# Test the CLI
create test-project
```

## License

MIT © 2025
npm package: @olierjs/oplot
Description: The starter is built on top of Vite 5.x and prepared for writing libraries in TypeScript. It generates a hybrid package - both support for CommonJS and ESM modules.
Author: TbhT
Latest version: 0.2.3

# vite-vanilla-ts-lib-starter

The starter is built on top of Vite 5.x and prepared for writing libraries in TypeScript. It generates a hybrid package - both support for CommonJS and ESM modules.

## Features

- Hybrid support - CommonJS and ESM modules
- IIFE bundle for direct browser support without bundler
- Typings bundle
- ESLint - scripts linter
- Stylelint - styles linter
- Prettier - formatter
- Vitest - test framework
- Husky + lint-staged - pre-commit git hook set up for formatting

## GitHub Template

This is a template repo. Click the green [Use this template](https://github.com/kbysiec/vite-vanilla-ts-lib-starter/generate) button to get started.

## Clone to local

If you prefer to do it manually with the cleaner git history

```bash
git clone https://github.com/kbysiec/vite-vanilla-ts-lib-starter.git
cd vite-vanilla-ts-lib-starter
npm i
```

## Checklist

When you use this template, update the following:

- Remove `.git` directory and run `git init` to clean up the history
- Change the name in `package.json` - it will be the name of the IIFE bundle global variable and bundle files name (`.cjs`, `.mjs`, `.iife.js`, `d.ts`)
- Change the author name in `LICENSE`
- Clean up the `README` and `CHANGELOG` files

And, enjoy :)

## Usage

The starter contains the following scripts:

- `dev` - starts dev server
- `build` - generates the following bundles: CommonJS (`.cjs`) ESM (`.mjs`) and IIFE (`.iife.js`). The name of bundle is automatically taken from `package.json` name property
- `test` - starts vitest and runs all tests
- `test:coverage` - starts vitest and run all tests with code coverage report
- `lint:scripts` - lint `.ts` files with eslint
- `lint:styles` - lint `.css` and `.scss` files with stylelint
- `format:scripts` - format `.ts`, `.html` and `.json` files with prettier
- `format:styles` - format `.cs` and `.scss` files with stylelint
- `format` - format all with prettier and stylelint
- `prepare` - script for setting up husky pre-commit hook
- `uninstall-husky` - script for removing husky from repository

## Acknowledgment

If you found it useful somehow, I would be grateful if you could leave a star in the project's GitHub repository.

Thank you.
npm package: @olifog/troute
Description: Simple, opinionated data fetching for the Next App router.
Author: Oliver Fogelin
Latest version: 0.4.4


# Troute

Simple, opinionated data fetching for the Next.js App router. Write all your queries in the same place, and use them across Server and Client Components easily.

## What is this?

Server Actions are great for mutations, and are the de facto way of POSTing data in both Server and Client components. For fetching data, Server Components can just call the query directly - no server action or API route needed. For Client Components though, you have to write route handlers for every single fetch action, and use a third-party client fetching library like React Query. This gets tedious - it would be cool to just be able to call the queries directly like in Server Components!

Troute automatically generates route handlers, and wraps around React Query, allowing you to call those same query functions from Client Components (without having to write all the route handlers.)

## Example

`queries/user.ts`

```typescript
import db from ...

export const getUser = async ({id}: {id: string}) => {
  return await db.findUser(id)
}
```

Fetching from a Server Component:

```tsx
import { getUser } from "@/queries/user"

export const User = async () => {
  const user = await getUser({id: '123'})

  return <div>{user.name}</div>
}
```

Fetching from a Client Component:

```tsx
"use client"

import { troute } from '@/troute'

export const User = () => {
  const { data: user } = troute.getUser({params: {id: '123'}})

  return <div>{user.name}</div>
}
```

## Setup

1. Install Troute:

    ```bash
    npm install @olifog/troute
    ```

2. In your root layout, add a TrouteProvider:

    ```tsx
    import { TrouteProvider } from '@olifog/troute'
    // ...

    export default function App({ Component, pageProps }) {
    // ...
      return (
        <TrouteProvider>
          <Component {...pageProps} />
        </TrouteProvider>
      )
    }
    ```

3. Create an `app/api/troute/route.ts` file:

    ```typescript
    export { GET } from '@/troute'
    ```

4. Create a `troute.ts` file in your project root:

    ```typescript
    import { createTroute } from "@olifog/troute";

    export const {GET, troute} = createTroute({})
    ```

5. Now you can start creating your queries as in the `queries` folder (or whatever other name you want):

    `queries/user.ts`

    ```typescript
    import db from ...

    export const getUser = async ({id}: {id: string}) => {
      return await db.findUser(id)
    }
    ```

6. And add any fetch queries you want to call from the client into the createTroute call in `troute.ts`:

    ```typescript
    import { createTroute } from "@olifog/troute";
    import { getUser } from "@/queries/user";

    export const {GET, troute} = createTroute({
      getUser
    })
    ```

An example app using Troute can be found [here](https://github.com/olifog/troute-example).
npm package: @olifyio/ts-odata-v4
Description: A typescript library to help generate odata queries
Author: Trekking for Charity
Latest version: 0.1.13


[![Build](https://travis-ci.org/TrekkingForCharity/ts-odata.svg?branch=master)](https://travis-ci.org/TrekkingForCharity/ts-odata)
[![npm version](https://badge.fury.io/js/ts-odata.svg)](//npmjs.com/package/ts-odata)

# ts-odata-v4

# Changelog
All notable changes to this project will be documented in this file.
ts-odata-v4 is forked [ts-odata project](https://www.npmjs.com/package/ts-odata).

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

## [0.1.2] - 2018-10-25
### Added
- Support for $search

## [0.1.1] - 2018-10-20
### Added
- Support date input

## [0.1.0] - 2018-10-16
### Added
- Support for OData 'Count' keyword

---

A typescript library to help generate odata queries
> This is a Typescript port of the javascript library [joData]: https://github.com/mccow002/joData

tsoData creates a javascript object that represents an oData query. This allows you to easily modify parts of your oData query without effecting the rest of it.

tsoData's goal is to implement 

All methods in tsoData are chainable.

## Getting Started

### Creating a TsoData object

To create a TsoData query object, you instantiate it by passing your base uri into the constructor.

	var query = new Tso('http://test.com');
	var query = new Tso('http://test.com');

### .baseUri

The base uri passed in through the constructor can be accessed by calling

	query.baseUri;

### .toString()

To get the query in oData format, call toString off of your query object.

	query.toString();

All further documentation is in the library definitions

##Unsupported Features (for now)

These are the list of features TsoData currently does not support. Hopefully, these features are coming soon.

###Filter

#### Type Functions

* IsOf

###Custom Query Options

TsoData currently does not support any custom query options
npm package: @olifyio/web-ifc-three
Description: This library is the implementation of [web-ifc](https://github.com/tomvandig/web-ifc) for [THREE.js](https://github.com/mrdoob/three.js/). This is the official IFCLoader of Three.js.
Author: IFC.js
Latest version: 0.0.125

ERROR: No README data found!
npm package: @oligami/shared-object
Description: Shared object like SharedArrayBuffer on the web
Author: oligami
Latest version: 0.1.1

# SharedObject
Enables object functions to be called from multiple workers on the Web

Some of the functions listed here can be used, although they are still under construction.
Currently, when async or await is called, it does not wait.

example:

```typescript:main.ts
import { SharedObject } from "../lib";
import { SharedObjectRef } from '../lib/ref';

const object = [{
  add(a: number, b: number) {
    return a + b;
  }
}];

const sharedObject = new SharedObject(object, "abcd");

const sharedObject2 = new SharedObject((a, b) => a * b, "tyu");

const w = new Worker(new URL("../src-dist/worker.js", import.meta.url).href, { type: "module" });
```

```typescript:worker.ts
import { SharedObjectRef } from "../lib/ref";

const sharedObjectRef = new SharedObjectRef("abcd");

const proxy = sharedObjectRef.proxy<[{ add(a: number, b: number): Promise<number> }]>();

const ret2 = await proxy[0].add(1, 2);

console.log(ret2);

const sharedObjectRef2 = new SharedObjectRef("tyu");

const proxy2 = sharedObjectRef2.proxy<(a: number, b: number) => number>();

console.log(await proxy2(6, 9));
```
npm package: @oligami/solid-jsx-renderer
Description: A Solidjs Component for Rendering JSX
Author: Akira Onishi
Latest version: 0.3.1

# solid-jsx-renderer

## Description
SolidJS JSX Renderer is a SolidJS Component for rendering JSX to SolidJS nodes.

It has a JavaScript Runtime inside, and can execute the user's JSX with controlled behavior.

[Launch Demo](https://oligami-0424.github.io/solid-jsx-renderer/)

## Features
- [x] Rendering JSX as SolidJS node
- [x] TypeScritpt ready
- [x] Provides CommonJS and ES Modules
- [x] JavaScript syntax and featues
  - without async, await and generator
- [x] Injectable custom SolidJS components
- [x] Pass binding variables
- [x] Applicable filters to parsed nodes
  - You can create allowlist / denylist filters to tagName, attributes or properties
  - Operation has not been checked.
- [x] Avoid user's call expressions
- [x] Avoid user's new expressions
- [x] Parse with meriyah
## My Features
- [x] Can use on SSR(solid-start)
- [x] Binding Component SSR
  - binding Component which has binding props is also ssr on internal
  - `<textarea value={signal()}>` is not ssr on solid-start. You should use `<textarea>{signal()}</textarea>`
- [x] Update only what is updated.
- [ ] can use Show, For, Index... (only SolidJS Component)

If there is a feature you want, please contact us at issue

Ported from:
[https://github.com/rosylilly/react-jsx-renderer](https://github.com/rosylilly/react-jsx-renderer) v1.3.1
See here for detailed instructions.

[This is sample code](https://github.com/oligami-0424/solid-jsx-renderer/tree/main/examples/solidjs)

## Installation

1. `npm install @oligami/solid-jsx-renderer` (or `pnpm add @oligami/solid-jsx-renderer`)
2. Add `import { JSXRenderer } from 'solid-jsx-renderer';`
3. `<JSXRenderer code="Hello, World" />` to render `Hello, World`

## Requirements

- **SolidJS**: latest
- **solid-start**: latest

## Options

disableKeyGeneration:
  This doesn't make any sense, so it would be lighter to turn it off.
npm package: @oligeon/pac
Description: This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
Author: oligeon
Latest version: 0.0.0

# React + TypeScript + Vite

This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.

Currently, two official plugins are available:

- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh

## Expanding the ESLint configuration

If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:

- Configure the top-level `parserOptions` property like this:

```js
   parserOptions: {
    ecmaVersion: 'latest',
    sourceType: 'module',
    project: ['./tsconfig.json', './tsconfig.node.json'],
    tsconfigRootDir: __dirname,
   },
```

- Replace `plugin:@typescript-eslint/recommended` to `plugin:@typescript-eslint/recommended-type-checked` or `plugin:@typescript-eslint/strict-type-checked`
- Optionally add `plugin:@typescript-eslint/stylistic-type-checked`
- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and add `plugin:react/recommended` & `plugin:react/jsx-runtime` to the `extends` list
npm package: @olimot/grab-n-pinch
Description: Grab n' pinch library for both desktop and mobile device.
Author: Seungmin Kim
Latest version: 1.0.0

# Grab N' Pinch

A libarary supporting panning and zooming for both desktop and mobile devices.

## Usage

```js
const gnp = new GrabNPinchManager({
  translate: { x: 0, y: 0 },
  scale: window.innerWidth / root.clientWidth,
  minScale: Math.min(0.5, window.innerWidth / root.clientWidth, window.innerHeight / root.clientHeight),
});

document.body.addEventListener('wheel', gnp.updateScaleInertia);
document.body.addEventListener('pointerdown', gnp.addPointer);
document.body.addEventListener('pointermove', gnp.updatePointer);
document.body.addEventListener('pointerleave', gnp.removePointer);
document.body.addEventListener('pointerup', gnp.removePointer);

let elapsed = 0;
(function raf() {
  requestAnimationFrame((time) => {
    const delta = time - elapsed;
    elapsed = time;
    gnp.run(delta);
    root.style.transformOrigin = '0 0';
    root.style.transform = `matrix(${gnp.scale}, 0, 0, ${gnp.scale}, ${gnp.translate.x},${gnp.translate.y})`;
    raf();
  });
})();
```
npm package: @olimpia.spyra/randomid-generator
Description: This package is a generator that helps you build random string with numbers and letters.
Author: Olimpia Spyra
Latest version: 1.0.4

This package is a generator that helps you build random string with numbers and letters.

INSTALL:
npm i @olimpia.spyra/randomid-generator

USE:
const randomID = require('@olimpia.spyra/randomid-generator');
npm package: @olio-rent/expo-mixpanel-analytics
Description: Mixpanel integration for use with React Native apps built on Expo 41.
Latest version: 1.3.1

Expo Mixpanel Analytics
=========

Mixpanel integration for use with React Native apps built on Expo.

Forked from `@bothrs/expo-mixpanel-analytics` to add support for Expo 41.

## Installation

```
npm install @olio-rent/expo-mixpanel-analytics --save
```

## Import

Your React Native app's screen resolution, app name, app ID, app version, device information will be automatically resolved and sent with each event.
```
import ExpoMixpanelAnalytics from '@olio-rent/expo-mixpanel-analytics';
```

## Usage
```
const analytics = new ExpoMixpanelAnalytics('5224da5bbbed3fdeaad0911820f1bf2x', { clientId: 'generatedClientId' });

analytics.init(); // returns a promise

analytics.identify('13793');

analytics.register({ email: 'bob@bob.com' }); // super props sent on every request and persisted in AsyncStorage

analytics.track('Signed Up', { 'Referred By': 'Friend' });

analytics.people_set({ '$first_name': 'Joe', '$last_name': 'Doe', '$email': 'joe.doe@example.com', '$created': '2013-04-01T13:20:00', '$phone': '4805551212', 'Address': '1313 Mockingbird Lane', 'Birthday': '1948-01-01' });

analytics.people_set_once({ 'First login date': '2013-04-01T13:20:00' });

analytics.people_unset([ 'Days Overdue' ]);

analytics.people_increment({ 'Coins Gathered': 12 });

analytics.people_append({ 'Power Ups': 'Bubble Lead' });

analytics.people_union({ 'Items purchased': ['socks', 'shirts'] });

analytics.people_delete_user();

analytics.reset();

```

## References
https://mixpanel.com/help/reference/http
npm package: @olioex/redux-persist-immutable-reconciler
Description: State Reconciler for immutable state
Author: Tania Papazafeiropoulou
Latest version: 0.3.0

# redux-persist-immutable-reconciler

### State reconciler for deep merging immutable state

[![Build Status](https://travis-ci.org/OLIOEX/redux-persist-immutable-reconciler.svg?branch=master)](https://travis-ci.org/OLIOEX/redux-persist-immutable-reconciler)

Implemented to work with [redux-persist-transform-filter-immutable](https://github.com/actra-development-oss/redux-persist-transform-filter-immutable)

Adapted from [this gist](https://gist.github.com/appelstroop/2e2ac063640b362aab612f6085cb1e7e) by appelstroop.
npm package: @olipas/simple-todo-app
Description: 미니멀한 디자인의 일별 할 일 관리 앱 - 로컬 파일 시스템에 데이터를 저장하는 간단한 Todo 앱
Author: olipas
Latest version: 1.0.3

# 오늘 할 일

미니멀한 디자인의 일별 할 일 관리 앱입니다.

## 주요 기능

- **할 일 추가/수정/삭제** — 제목과 선택적 상세 설명을 함께 기록
- **완료 체크** — 체크박스로 완료 상태 토글, 완료된 항목은 취소선 처리
- **날짜별 관리** — 이전/다음 날짜 탐색으로 날짜별 할 일을 독립 관리
- **로컬 파일 저장** — 날짜별로 JSON 파일로 저장되어 영구적으로 데이터 보존
- **인라인 편집** — 할 일 클릭 시 바로 제목·설명 수정 가능
- **키보드 단축키**
  - `Enter` — 할 일 추가
  - `Tab` — 상세 설명 입력으로 이동
  - `Ctrl/Cmd + ←/→` — 이전/다음 날짜
  - `Ctrl/Cmd + T` — 오늘로 이동

## 설치 및 실행

### npx로 바로 실행 (권장)

```bash
npx @olipas/simple-todo-app
```

### npm으로 글로벌 설치

```bash
npm install -g @olipas/simple-todo-app
todo
```

설치 후 `todo` 명령어로 실행하면 자동으로 브라우저가 열립니다.

### 로컬 개발 환경에서 실행

```bash
# 의존성 설치
npm install

# 서버 실행
npm start
```

앱이 실행되면 자동으로 브라우저가 열리며 `http://localhost:3456`에서 접속 가능합니다.

## 데이터 저장 위치

모든 할 일 데이터는 사용자 홈 디렉토리에 날짜별 JSON 파일로 저장됩니다:

```
~/.simple-todo-app/
  ├── 2026-02-12.json
  ├── 2026-02-13.json
  └── ...
```

각 JSON 파일은 해당 날짜의 모든 할 일을 포함하며, 파일을 직접 편집하거나 백업할 수 있습니다.

## 기술 스택

- **Backend**: Node.js, Express
- **Frontend**: HTML / CSS / Vanilla JavaScript
- **Storage**: 로컬 JSON 파일 (파일 시스템)
- **Fonts**: Google Fonts (Noto Serif JP, DM Sans)

## 디자인

크림색 배경에 테라코타 포인트 컬러를 사용한 미니멀 디자인입니다. 종이 질감 텍스처, 부드러운 애니메이션, 커스텀 체크박스 등으로 감성적인 사용 경험을 제공합니다.
npm package: @oliphantom/fastify-mastodomo
Description: MastoDomo is a Fastify project that interacts with the Mastodon API, providing plugins for handling server-select, Oauth, and token capture
Author: Oliphant
Latest version: 1.0.12

# Getting Started with [Fastify-CLI](https://www.npmjs.com/package/fastify-cli)
This project was bootstrapped with Fastify-CLI.

## Available Scripts

In the project directory, you can run:

### `npm run dev`

To start the app in dev mode.\
Open [http://localhost:3000](http://localhost:3000) to view it in the browser.

### `npm start`

For production mode

### `npm run test`

Run the test cases.

### `npm run build`

## Learn More

To learn Fastify, check out the [Fastify documentation](https://www.fastify.io/docs/latest/).