open-index/open-npm huggingface dataset:
npm package: @nerevu/cachebust-brunch
Description: Rename assets based on SHA1 hash for cache busting
Author: Reuben Cummings
Latest version: 0.5.0

# cachebust-brunch

The best of [fingerprinter-brunch](https://github.com/paulcsmith/fingerprinter-brunch), [hashfingerprint-brunch](https://github.com/jvanderneutstulen/hashfingerprint-brunch), and [timestamp-brunch](https://github.com/fabienL/timestamp-brunch).

A [Brunch][] plugin that will rename assets with an unique SHA hash. This will allow better caching of assets. It will automatically rewrite the urls, and also write to a manifest file.

## Usage

`npm install --save cachebust-brunch`

_Note: make sure cachebust-brunch is listed *before* [gzip-brunch][]  in the dependency list of your package.json_

_Note: make sure cachebust-brunch is listed *after* [uglify-brunch][] in the dependency list of your package.json_

## Options

Default configuration:

```coffeescript
module.exports = config:
  plugins:
    cachebust:
      manifest: 'public/manifest.json'
      environments: ['production']
      reference: 'index.html'
      extensions: [
        /\.js$/
        /\.css$/
      ]
      precision: 8
      enabled: true
```

### manifest

Output location of the manifest file.

### reference

The file where the urls should be rewritten.

### extensions

Array of extensions to match. Regex must be acceptable by `str.match`.
The array will be matched against the list of generated files.

### precision

The number of characters of the SHA1 hash to use in the hashed
filename. Default should be fine.

### enabled

Whether or not the plugin is enabled.

## Brunch build

```
brunch build
```

Script tags will compile as

```html
<script src="js/vendor.js"></script>
<script src="js/app.js"></script>
```

```
brunch build --production
```

Script tags will compile as

```html
<script src="js/vendor-24179978.js"></script>
<script src="js/app-24179978.js"></script>
```

## License

MIT

[Brunch]: http://brunch.io
[gzip-brunch]: https://github.com/banyan/gzip-brunch
[uglify-brunch]: https://github.com/brunch/uglify-js-brunch
npm package: @nerevu/html2hs
Description: Convert HTML to Mithriljs flavored Hyperscript
Author: Reuben Cummings
Latest version: 1.1.3

[![Build Status](https://travis-ci.org/nerevu/html2hs.svg?branch=master)](https://travis-ci.org/unframework/html2hs)

# Convert Legacy HTML to Hyperscript

Automatically translate old HTML markup into the new Hyperscript markup embeddable directly inside your component Javascript code.

Use this for hand-converting legacy project source code (e.g. AngularJS templates): care is taken to preserve original whitespace and even comments. For dynamic serving and CI builds check out https://github.com/alexmingoia/jsx-transform instead.

```
npm install -g @nerevu/html2hs
html2hs file.html [file2.html ...]
cat file.html | html2hs
```

See Hyperscript library: https://github.com/dominictarr/hyperscript

Also useful for virtual DOM Hyperscript-like syntax: https://github.com/Matt-Esch/virtual-dom

HTML goes in:

```html
<table class="sample-html">
  <tr>
    <th>Pandas</th>
    <th>Kittens</th>
    <th>Hedgehogs</th>
  </tr>
  <tr>
    <td>foo</td>
    <td>bar</td>
    <td>baz</td>
  </tr>
  <tr>
    <td>32</td>
    <td>45</td>
    <td>83</td>
  </tr>
  <tr>
    <td>onomatopoeia</td>
    <td>schadenfreude</td>
    <td>antidisestablishmentarianism</td>
  </tr>
</table>
```

Hyperscript-like JS syntax comes out:

```js
m("table.sample-html", [
  m("tr", [
    m("th", "Pandas"),
    m("th", "Kittens"),
    m("th", "Hedgehogs")
  ]),
  m("tr", [
    m("td", "foo"),
    m("td", "bar"),
    m("td", "baz")
  ]),
  m("tr", [
    m("td", "32"),
    m("td", "45"),
    m("td", "83")
  ]),
  m("tr", [
    m("td", "onomatopoeia"),
    m("td", "schadenfreude"),
    m("td", "antidisestablishmentarianism")
  ])
])
```
npm package: @nerevu/prettier-coffee
Description: Convert Coffeescript into prettier Coffeescript
Author: Reuben Cummings
Latest version: 1.1.0

# Prettier Coffeescript

Uses [prettier-plugin-coffeescript](https://github.com/helixbass/prettier-plugin-coffeescript) to prettify Coffeescript.

```
npm install -g @nerevu/prettier-coffee
prettier-coffee [options] file.coffee [file2.coffee ...]
cat file.coffee | prettier-coffee
```

Coffeescript goes in:

```coffee
m 'table.sample-html', [
  m('tr', [
    m('th', 'Pandas')
    m('th', 'Kittens')
    m('th', 'Hedgehogs')
  ])
  m('tr', [
    m('td', 'foo')
    m('td', 'bar')
    m('td', 'baz')
  ])
  m('tr', [
    m('td', '32')
    m('td', '45')
    m('td', '83')
  ])
  m('tr', [
    m('td', 'onomatopoeia')
    m('td', 'schadenfreude')
    m('td', 'antidisestablishmentarianism')
  ])
]
```

prettified Coffeescript comes out:

```coffee
m "table.sample-html", [
  m "tr", [m("th", "Pandas"), m("th", "Kittens"), m "th", "Hedgehogs"]
  m "tr", [m("td", "foo"), m("td", "bar"), m "td", "baz"]
  m "tr", [m("td", "32"), m("td", "45"), m "td", "83"]
  m "tr", [
    m "td", "onomatopoeia"
    m "td", "schadenfreude"
    m "td", "antidisestablishmentarianism"
  ]
]
```
npm package: @nerfzael/http-plugin-wrapper
Description: Polywrap HTTP Javascript Plugin
Latest version: 0.3.0

# HTTP Plugin

Http plugin curently supports two different methods `GET` and `POST`. Similar to calling axios, when defining request you need to specify a response type. Headers and query parameters may also be defined.

## Response Types

`TEXT` - The server will respond with text, the HTTP plugin will return the text as-is.

`BINARY` - The server will respond with binary data (_ArrayBuffer_), the HTTP plugin will encode as a **base64** string and return it.

## GET request

Below is sample invocation of the `GET` request with custom request headers and query parameters (`urlParams`).

```ts
const response = await polywrapClient.query<{ get: Response }>({
uri: new Uri("wrap://ens/http.polywrap.eth"),
  query: `
    query {
      get(
        url: "http://www.example.com/api"
        request: {
          responseType: TEXT
          urlParams: [{key: "query", value: "foo"}]
          headers: [{key: "X-Request-Header", value: "req-foo"}]
        }
      )
    }
  `
})
```

## POST request

Below is sample invocation of the `POST` request with custom request headers and query parameters (`urlParams`). It is also possible to set request body as shown below.

```ts
const response = await polywrapClient.query<{ get: Response }>({
  uri: new Uri("wrap://ens/http.polywrap.eth"),
  query: `
    query {
      post(
        url: "http://www.example.com/api"
        request: {
          responseType: TEXT
          urlParams: [{key: "query", value: "foo"}]
          headers: [{key: "X-Request-Header", value: "req-foo"}]
          body: "{data: 'test-request'}"
        }
      )
    }
  `
})
```
npm package: @nerfzael/pwr
Description: ## Description Polywrap Wrapper Runner (PWR) is a CLI application for running Polywrap wrappers. It uses the PolywrapClient to execute any wrapper that implements the PwrApp interface wrap://ens/pwr-app.eth ```graphql type Module { main(args: [String!]!):
Author: nerfZael
Latest version: 0.2.0

# Polywrap Wrapper Runner (PWR)

## Description
Polywrap Wrapper Runner (PWR) is a CLI application for running Polywrap wrappers.
It uses the PolywrapClient to execute any wrapper that implements the PwrApp interface wrap://ens/pwr-app.eth
```graphql
type Module {
  main(args: [String!]!): UInt8!
}
```

## Examples: 
Input: `pwr wrap://ens/wrap-echo.eth Hello world!`
Output: `Hello world!`

Input: `pwr ens/wrap-echo.eth Hello world!`
Output: `Hello world!`

Input: `pwr wrap-echo.eth Hello world!`
Output: `Hello world!`

Input: `pwr wrap://ipfs/Qm Hello world!`
Output: `Hello world!`

Input: `pwr ipfs/Qm Hello world!`
Output: `Hello world!`

Input: `pwr ipfs://Qm Hello world!`
Output: `Hello world!`

Input: `pwr Qm Hello world!`
Output: `Hello world!`
npm package: @nerfzael/wrap-persistence-node
Description: Wrap persistence node is a node.js console app with an integrated IPFS node that can crawl/listen for all ENS wrapper registrations (via content records) and automatically pin the IPFS URIs. It achieves that by watching for the "Contenthash changed" event
Author: nerfZael
Latest version: 0.3.13

# Wrap persistence node

Wrap persistence node is a node.js console app with an integrated IPFS node that can crawl/listen for all ENS wrapper registrations (via content records) and automatically pin the IPFS URIs.
It achieves that by watching for the "Contenthash changed" events of the public ENS resolver, reading the IPFS hash of the records and automatically pinning the contents at that IPFS hash (only if the contents contain a valid wrapper).

It also has an integrated IPFS gateway that exposes the local IPFS node through an HTTPS API.

### Run without cloning the repo:
1. Install with "npm install -g @nerfzael/wrap-persistence-node"
2. Create .env file from the .env.template in the directory where you want to execute the node
3. In that directory, run "wrap-persistence-node {command}"

### Run with cloning the repo:
1. Clone the repo
2. Run "nvm install && nvm use"
3. Run "yarn" to install dependencies
4. Create a .env file from the .env.template and fill in the required information
5. Run "yarn dev {command}" to run the commands with ts-node

### The following commands are supported:
- past:            Run for a past block count
- missed:          Run for missed blocks while the app was offline
- listen:          Listen for events and pin wrappers
- unresponsive:    Process unresponsive IPFS URIs
- info:            Display useful information about the current state (pinned hash count, unresponsive count, etc)
- reset:           Delete the storage file
- api              Run the IPFS gateway API
- help:  display help for command
npm package: @nerfzael/wrappers
Description: Wrappers is a command-line tool for publishing polywrappers to IPFS and ENS. IPFS publishing is done via a wrap-persistence-node endpoint (https://www.npmjs.com/package/@nerfzael/wrap-persistence-node). By default it publishes to the public https://ipfs.w
Author: nerfZael
Latest version: 0.2.2

# Wrappers

Wrappers is a command-line tool for publishing polywrappers to IPFS and ENS.
IPFS publishing is done via a wrap-persistence-node endpoint (https://www.npmjs.com/package/@nerfzael/wrap-persistence-node).
By default it publishes to the public https://ipfs.wrappers.io endpoint.

### Install and run:
1. Install with "npm install -g @nerfzael/wrappers"
3. In your wrapper directory (or the wrapper build directory) run "wrappers {command}"

#### Publish to IPFS:
```
wrappers ipfs
```

#### Set up an Ethereum connection:
```
wrappers connection -n rinkeby -p https://rinkeby.infura.io/v3/9aa3d95b3bc440fa88ea12eaa4456161 -pk <Your private key>
```
You will be asked for a password to use for the private key encryption.
You can choose to save the password to disk(-s option), so that you do not have to type it in every time you publish to ENS) 

#### Publish to ENS:
```
wrappers ens -d my-domain.eth -n rinkeby
```
You need to have an Ethereum connection set up for the network you are trying to publish to.
If you have chosen not to save the password to disk, the cli will ask you to type it in.

### The following commands are supported:
- ipfs:        Publish the wrapper to IPFS
- ens:         Publish the wrapper to ENS
- connection:  Set up an ethereum connection (provider and encrypted private key)
- help:  display help for command
npm package: @neriko/cloudflare-workers-router
Description: 0 dependencies tiny router for cloudflare workers
Author: @nerikeshi-k
Latest version: 0.1.2

# cloudflare-workers-router

0 dependencies tiny router for cloudflare workers

# install

if you use npm,

```sh
$ npm i @neriko/cloudflare-workers-router
```

if you use yarn,

```sh
$ yarn add @neriko/cloudflare-workers-router
```

# usage

## 1. Create router

```ts
const router = new Router();
```

## 2. Add static paths

```ts
router.get('/', async (req) => new Response('index page'));
router.post('/articles', async (req) => {
  // create article, etc
  return new Response('article created response');
});
```

## 3. Add dynamic paths

```ts
router.get('/articles/:id', async (req, params) => {
  // get article, etc
  return new Response('article response');
});

router.get('/articles/setting', async (req, params) => {
  // will match '/articles/setting'
  return new Response('article setting response');
});

router.get('/static/*', async (req) => {
  // handle any static assets
  return new Response('statics');
});
```

## 4. Handle Request

```ts
addEventListener('fetch', (event) => {
  return event.respondWith(router.handle(event.request));
});
```
npm package: @nerimity/flakeid
Description: Time based 64-bit unique id generator, inspired by Twitter id (snowflake)
Author: Supertiger
Latest version: 1.0.3

# Fork of FlakeId
Fork was made to it work with esm and cjs.

# FlakeId
A tiny module to generate time based 64-bit unique id, inspired by Twitter id (snowflake).

FlakeId takes 42 bit of timestamp, 10 bit of machine id (or any random number you provide), 12 bit of sequence number .  As javascript is limited to 53 bit integer precision, FlakeId generates id in string format like "285124269753503744", which can be easily type casted into 64 bit bigint in database.

# Installation

```js
npm install @nerimity/flakeid
```

# Usage
Initializtion
```js
import {FlakeId} from 'flakeid';
// const {FlakeId} = require('flakeid');

//initiate flake
const flake = new FlakeId({
	mid : 42, //optional, define machine id
    timeOffset : (2013-1970)*31536000*1000 //optional, define a offset time
});
```
Create a instance of flake as shown above which will be used to generate flake ids afterward.

Id generation
```js
const id1 = flake.gen(); \\returns something like 285124269753503744
const id2 = flake.gen(); \\returns something like 285124417543999488
```

# Options

mid : (Default to 1) A machine id or any random id. If you are generating id in distributed system, its highly advised to provide a proper mid which is unique to different machines.

timeOffset : (Defaults to 0) Time offset will be  subtracted from current time to get the first 42 bit of id. This help in generating smaller ids.

# Method
gen : Method to generate id from FlakeId instance.

------
As js have 53bit integer precision, Flake Id uses a smart solution by Dan Vanderkam (http://www.danvk.org/hex2dec.html) to convert hex to decimal without loosing precision. 
*Source code for converting hex to decimal is taken from http://www.danvk.org/hex2dec.html which have APACHE LICENCE*
npm package: @nerimity/i18lite
Description: i18next lite
Author: SupertigerDev
Latest version: 1.2.0

# i18lite

![npm (scoped)](https://img.shields.io/npm/v/@nerimity/i18lite?color=seagreen)
[![codecov](https://codecov.io/gh/nerimity/i18lite/branch/main/graph/badge.svg?token=RGWEZWK8T2)](https://codecov.io/gh/nerimity/i18lite)
[![npm bundle size](https://img.shields.io/bundlephobia/minzip/@nerimity/i18lite)](https://bundlephobia.com/package/@nerimity/i18lite)
npm package: @nerimity/nevula
Description: A (relatively) simple and (hopefully) performant markup parser
Author: brecert
Latest version: 0.15.0

# Nevula
> A (relatively) simple and (hopefully) performant markup parser made for nerimity.

**Please note, this is not a markdown parser, this is its own special markup format called nevula, a specification for this format is a work in progress.**

This project has grown out of a need for a relatively simple renderer agnostic, reasonably performant markup parser with a relatively small code size.

# Features

## renderer agnostic
The outputted entity format is fairly simple and has been designed to make it easy to make renderers for.

## relatively simple
This may change over time, but for now it only parses a fairly restricted set of rules intented to make sense.

An example of this is the italic syntax, `//` looks slanted like italicized text and two slashes are used to be consistent with other rules and to make it easier to avoid conflicts with other text.

## reasonably performant
see: [Benchmarks](#Benchmarks)

# Benchmarks
Just to be clear, many types of benchmarks will favour this markup because of it's smaller surface area compared to something like a full markdown parser.

<!-- BENCHMARKS START -->
## Simple Markup

```md
> **Hello world!**

**__inside__ __inside again__**

``code``

** ~~not~~ a complete marker! __complete__
```
|Name|Runs|Total (ms)|Average (ms)|
|:--|--:|--:|--:|
|nevula|2500|153.699|0.061|
|nevula with inserted text spans|2500|159.208|0.064|
|/x/markdown@v2.0.0 (based on an older version of Marked)|2500|284.173|0.114|
<!-- BENCHMARKS END -->
npm package: @nerimity/solid-emoji-picker
Description: SolidJS Emoji Picker modal.
Author: Supertigerr
Latest version: 0.4.9

<p>
  <img width="100%" src="https://assets.solidjs.com/banner?type=solid-emoji-picker&background=tiles&project=%20" alt="solid-emoji-picker">
</p>

# solid-emoji-picker

[![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc00ff.svg?style=for-the-badge&logo=pnpm)](https://pnpm.io/)

SolidJS Emoji Picker modal.

## Quick start

Install it:

```bash
npm i solid-emoji-picker
# or
pnpm add solid-emoji-picker
```

Use it:

```tsx
import { EmojiPicker } from 'solid-emoji-picker';
import { emojis } from 'solid-emoji-picker/emojis';


const App = () => {
  return (
    <div>
      <EmojiPicker spriteUrl="/emojiSprites.png" emojis={emojis} />
    </div>
  )
}

export default App
```

## Events
```js
onEmojiClicked: (Emoji) => void;
```
## Properties
```js
primaryColor = "#77a8f3"
categories = string[]
emojis = Emoji[]
maxRow = 7
spriteUrl = "/emojiSprites.png" // located in dev/public/
```

## Emoji
```json
{
    "emoji": "😀",
    "short_names": ["grinning"],
    "category": "Smileys & Emotion"
}
```
npm package: @nerimity/solid-opus-media-recorder
Description: Opus ogg mic recorder to blob
Author: Nerimity
Latest version: 1.0.1

<p>
  <img width="100%" src="https://assets.solidjs.com/banner?type=@nerimity/solid-opus-media-recorder&background=tiles&project=%20" alt="@nerimity/solid-opus-media-recorder">
</p>

# @nerimity/solid-opus-media-recorder

[![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc00ff.svg?style=for-the-badge&logo=pnpm)](https://pnpm.io/)

Opus ogg mic recorder to blob


## Quick start

Install it:

```bash
npm i @nerimity/solid-opus-media-recorder
# or
yarn add @nerimity/solid-opus-media-recorder
# or
pnpm add @nerimity/solid-opus-media-recorder
```


# Important
Before using this library, make sure to create a seperate `init.ts` file and import it from your main/index.ts.
```js
// init.ts
window.global ||= window;

// index/main.ts
import './init';

```



Use it:

```tsx
import { useMicRecorder } from '@nerimity/solid-opus-media-recorder'

const App = () => {
  const {record, stop} = useMicRecorder();

  const onRecordClick = async () => {
    console.log("recording...")
    const blob = await record();
    console.log("recorded", blob)
  }

  return (
    <div>
      <button onClick={onRecordClick}>Record</button>
      <button onClick={stop}>Stop</button>
    </div>
  )
}

export default App

```
npm package: @nerimity/solid-turnstile
Description: SolidJS library for Cloudflare Turnstile
Author: Supertigerr
Latest version: 1.1.0

<p>
  <img width="100%" src="https://assets.solidjs.com/banner?type=solid-turnstile&background=tiles&project=%20" alt="solid-turnstile">
</p>

# solid-turnstile

[![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc00ff.svg?style=for-the-badge&logo=pnpm)](https://pnpm.io/)

SolidJS library for Cloudflare Turnstile.   

Inspired by https://github.com/Le0developer/react-turnstile


## Quick start

Install it:

```bash
npm i solid-turnstile
# or
yarn add solid-turnstile
# or
pnpm add solid-turnstile
```

Use it:

```tsx
import {Turnstile} from "solid-turnstile";

function TurnstileWidget() {
  let ref: TurnstileRef | undefined;

  createEffect(() => {
    ref?.reset() // resets the captcha whenever you need to.
  })

  return (
    <Turnstile
      ref={ref}
      sitekey="1x00000000000000000000AA"
      onVerify={(token) => alert(token)}
    />
  );
}
```

Arguments

| Name               | Type    | Description                                           |
| -----------------  | ------- | ----------------------------------------------------- |
| sitekey            | string  | sitekey of your website                               |
| theme?             | string  | one of "light", "dark", "auto"                        |
| retry?             | string  | one of "auto", "never"                                |
| autoResetOnExpire? | boolean | automatically reset the widget when the token expires |

Callbacks

| Name      | Arguments  | Description                                |
| --------- | ---------  | ------------------------------------------ |
| onVerify   | token     | called when challenge is passed            |
| onLoad?    | widgetId  | called when the widget is loaded           |
| onError?   | error     | called when an error occurs                |
| onExpire?  | -         | called when the token expires              |
| onTimeout? | -         | called when the challenge expires          |
npm package: @nerimity/uiohook-napi
Description: [![](https://img.shields.io/npm/v/uiohook-napi/latest?color=CC3534&label=uiohook-napi&logo=npm&labelColor=212121)](https://www.npmjs.com/package/uiohook-napi)
Author: SupertigerDev
Latest version: 1.6.1

# uiohook-napi

[![](https://img.shields.io/npm/v/uiohook-napi/latest?color=CC3534&label=uiohook-napi&logo=npm&labelColor=212121)](https://www.npmjs.com/package/uiohook-napi)

N-API C-bindings for [libuiohook](https://github.com/kwhat/libuiohook).


### Usage example

```typescript
import { uIOhook, UiohookKey } from 'uiohook-napi'

uIOhook.on('keydown', (e) => {
  if (e.keycode === UiohookKey.Q) {
    console.log('Hello!')
  }

  if (e.keycode === UiohookKey.Escape) {
    process.exit(0)
  }
})

uIOhook.start()
```

### API

```typescript
interface UiohookNapi {
  on(event: 'input', listener: (e: UiohookKeyboardEvent | UiohookMouseEvent | UiohookWheelEvent) => void): this

  on(event: 'keydown', listener: (e: UiohookKeyboardEvent) => void): this
  on(event: 'keyup', listener: (e: UiohookKeyboardEvent) => void): this

  on(event: 'wheel', listener: (e: UiohookWheelEvent) => void): this

  keyToggle(key: keycode, toggle: 'down' | 'up')
}

export interface UiohookKeyboardEvent {
  altKey: boolean
  ctrlKey: boolean
  metaKey: boolean
  shiftKey: boolean
  keycode: number
}


```
npm package: @nerioslamaj/user-tracking
Description: This project has been implemented to accomplish the module FC7P01, M.Sc. Computing Science and Information Systems of the M.Sc. in the area of Computing conducted by the London Metropolitan University.
Author: Nerios Lamaj
Latest version: 1.1.4

## User Track Library

This project has been implemented to accomplish the module FC7P01, M.Sc. Computing Science and Information Systems of the M.Sc. in the area of Computing conducted by the London Metropolitan University. 

An easy pluggable NPM package that makes use of [libsvm](https://github.com/mljs/libsvm) library and [bayes](https://github.com/ttezel/bayes) library, to predict in real time whether a user is going to purchase a product or not.

### Installation
To install the library use `npm i @nerioslamaj/user-tracking`.
npm package: @nerisma/di
Description: [![npm version](https://badge.fury.io/js/%40nerisma%2Fdi.svg)](https://badge.fury.io/js/%40nerisma%2Fdi)
Author: Nerisma
Latest version: 1.0.14

# @nerisma/di

[![npm version](https://badge.fury.io/js/%40nerisma%2Fdi.svg)](https://badge.fury.io/js/%40nerisma%2Fdi)

## Installation
```bash
npm install @nerisma/di
```

## Description

This is a simple dependency injection library for TypeScript. It allows you to resolve dependencies automatically.

To be able to use a dependency, just mark its class with the `@Dependency` decorator and use the `Container.resolve` method to get an instance of it.

## Features

### Resolve a dependency 

To resolve a dependency, use the `Container.resolve` method.

**Note:** if the dependency does not yet exist in the container, it will be created and injected into to the container. 
If a dependency needs other dependencies, they will be resolved and injected as well.

```typescript
import {Container, Dependency} from '@nerisma/di';

@Dependency() // This is needed to enable dependency resolution via the constructor
class A {
    constructor(public b: B) {}
}

@Dependency() // This is needed to be injected
class B {
    constructor() {}
}

const a = Container.resolve<A>(A);
console.log(a.b); // This will print an instance of B
```

### Add a specific instance to the container

You may want to add a specific instance to the container manually, you can use the `Container.inject` method.

```typescript
import {Container, Dependency} from '@nerisma/di';

@Dependency()
class A {
    constructor() {}
}

const a = new A();

// This will inject 'a' as the instance of A into the container
Container.inject(a);
```

### Inject a class that is not decorated with `@Dependency`

Sometimes you might want to inject a class that is not decorated with `@Dependency` so its instance can be injected in a dependecy.

You can do this by using the `Container.inject` method with the `force` parameter inject to `true`.

```typescript
import {Container, Dependency} from '@nerisma/di';

class A {
    constructor() {}
}

@Dependency()
class B {
    constructor(public a: A) {}
}

const a = new A();
Container.inject(a, true); // a is now injectable in any dependency

const b = Container.resolve<B>(B);
console.log(b.a); // This will print an instance of A)
```

### Clearing the container

To clear the container of all dependencies, use the `Container.clear` method without any arguments.

You can also clear the container of specific types by providing those types as arguments.

```typescript
import {Container, Dependency} from '@nerisma/di';

Container.clear(); // This will clear all dependencies
Container.clear(A); // This will clear instance of A

const dependencies = [A, B];
Container.clear(...dependencies); // This will clear instance of A and B
Container.clear(A, B); // This will also clear instance of A and B
```