open-index/open-npm huggingface dataset:
npm package: @helix-one/paper
Description: An Angular wysiwyg editor
Author: Zubair Lawrence
Latest version: 0.0.2

# Paper

This project was generated with [Angular CLI](https://github.com/angular/angular-cli) version 1.4.9.

## Development server

Run `ng serve` for a dev server. Navigate to `http://localhost:4200/`. The app will automatically reload if you change any of the source files.

## Code scaffolding

Run `ng generate component component-name` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module`.

## Build

Run `ng build` to build the project. The build artifacts will be stored in the `dist/` directory. Use the `-prod` flag for a production build.

## Running unit tests

Run `ng test` to execute the unit tests via [Karma](https://karma-runner.github.io).

## Running end-to-end tests

Run `ng e2e` to execute the end-to-end tests via [Protractor](http://www.protractortest.org/).

## Further help

To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI README](https://github.com/angular/angular-cli/blob/master/README.md).
npm package: @helix-re/url-pattern
Description: Validate URLs and extract values easily!
Author: Lubos
Latest version: 1.0.1

# URL Pattern

Validate URLs and extract values easily!

## Installation

Using npm

```sh
npm i @helix-re/url-pattern
```

## Usage

>Note: URL Pattern supports both ES and CJS modules.

To use the APIs, you will need to understand the concept of a namespace. We define namespace as one or more characters between 2 slashes. Let's look at an example URL.

```sh
https://example.com/foo/bar/
```

We recommend using URL Pattern only with the `pathname` part of the URL.

```sh
/foo/bar/
```

We also define a concept of named and anonymous namespaces. Let's see how they work in practice on the example URL. There are 2 anonymous namespaces `foo` and `bar`, or 1 named namespace `foo` with value `bar`.

The reason we define 2 concepts is that a typical application might use a combination of both. For example, if we look at the HELIX RE office on Google Maps.

```sh
https://google.com/maps/place/HELIX+RE/@51.5333649,-0.1075597,17z/data=!3m1!4b1!4m5!3m4!1s0x48761bb724ab195d:0x1c29f788dbea0821!8m2!3d51.5333649!4d-0.1053657
```

Again, remove the domain part.

```sh
/maps/place/HELIX+RE/@51.5333649,-0.1075597,17z/data=!3m1!4b1!4m5!3m4!1s0x48761bb724ab195d:0x1c29f788dbea0821!8m2!3d51.5333649!4d-0.1053657
```

- `maps` is an anonymous namespace
- `place` is a named namespace with value `HELIX+RE`
- `@51.5333649,-0.1075597,17z` is an anonymous namespace
- `data=!3m1!4b1!4m5!3m4!1s0x48761bb724ab195d:0x1c29f788dbea0821!8m2!3d51.5333649!4d-0.1053657` is an anonymous namespace

Let's look at how we can extract the `place` namespace with URL Pattern.

```js
import { required, select } from '@helix-re/url-pattern';

const pattern = required() + select('place');
url.match(new RegExp(`^${pattern}`))[1]; // 'HELIX+RE'
```

All we had to do was require an anonymous namespace (`maps`) and select the value of a named namespace `place`.

Another common use case is defining optional namespaces. Let's assume Google Maps works even if you skip the initial `/maps/` prefix. We could make our selector work like this.

```js
import { optional, select } from '@helix-re/url-pattern';

const pattern = optional('maps') + select('place');
url.match(new RegExp(`^${pattern}`))[1]; // 'HELIX+RE'
```

Our pattern will now match the following URL as well.

```sh
/place/HELIX+RE/@51.5333649,-0.1075597,17z/data=!3m1!4b1!4m5!3m4!1s0x48761bb724ab195d:0x1c29f788dbea0821!8m2!3d51.5333649!4d-0.1053657
```

## API

### `- optional(values)`

Denotes one or more optional anonymous namespaces. Note that you need to know their values in advance.

### `- required(name)`

Denotes a required namespace. Accepts an optional `name` parameter. If skipped, we require an anonymous namespace.

### `- select(name)`

Selects a namespace value which can be accessed in the matched result. Accepts an optional `name` parameter. If skipped we select an anonymous namespace.
npm package: @helix-server/core
Description: Backend-framework
Latest version: 0.1.0

# helix

Backend-framework

## Installation

```bash
bun add helix
```

## Usage

```typescript
import { greet } from 'helix';

console.log(greet('World')); // Hello, World!
```

## Contributing

Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for contribution guidelines.

## License

MIT
npm package: @helix-server/utils
Description: utils for helix
Latest version: 0.1.1

# helix-utils

utils for helix

## Installation

```bash
bun add helix-utils
```

## Usage

```typescript
import { greet } from 'helix-utils';

console.log(greet('World')); // Hello, World!
```

## Contributing

Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for contribution guidelines.

## License

MIT
npm package: @helix-sleep/envault
Description: Sync your .env file with Envault.
Author: Envault
Latest version: 3.2.0

# Envault CLI

The Envault CLI allows you to connect to your [Envault server](https://github.com/envault/enevault) and sync its credentials to your local .env file.

## Usage

To use the Envault CLI, you must have [Node.js](https://nodejs.org/) installed on your computer.

On your Envault dashboard, you will find an initialization command for each environment, which you can run to establish a connection to your Envault server, and pull your variables. This command only needs to be run the first time you connect your .env to Envault. An example initialization command:

```
npx envault vault.envault.dev 84632 iCNaGGLou6v0mRas
```

After you've run your environment initialization command for the first time, you can pull your .env again easily:

```
npx envault
```

### Options

By default, Envault will not pull variables that are not already present in your .env file. To enable this behaviour, use the `--constructive` flag:

```
npx envault --constructive
```

You are able to customise the name of your .env file using the `--filename` flag:

```
npx envault vault.envault.dev 84632 iCNaGGLou6v0mRas --filename=.myenv
```

The Envault CLI will sometimes prompt you to confirm your actions, especially those made in constructive mode. To bypass these prompts, use the `--force` flag:

```
npx envault --force
```

## Need Help?

🐞 If you spot a bug with Envault, please [submit a detailed issue](https://github.com/envault/envault/issues/new), and wait for assistance.

🤔 If you have a question or feature request, please [start a new discussion](https://github.com/envault/envault/discussions/new).

🔐 If you discover a vulnerability within Envault, please review our [security policy](https://github.com/envault/cli/blob/master/SECURITY.md).
npm package: @helixlabs/mcp
Description: CLI tool to setup Helix MCP server
Author: Adarsh Dubey
Latest version: 1.1.0

# @helixlabs/mcp

CLI tool to setup Helix MCP server in Cursor and VS Code.

## Installation

No installation needed! Just run one of the following commands:

### Install for Cursor
```bash
npx @helixlabs/mcp init --cursor
```

### Install for VS Code
```bash
npx @helixlabs/mcp init --vscode
```

### Install for both

```bash

npx @helixlabs/mcp init --all
```

After installation, restart your editor, go to the MCP Servers tab and authenticate with your GitHub account.
npm package: @helixml/apps-client
Description: ![helix logo](docs/helix_logo.png)
Latest version: 0.1.3

# @helixml/apps-client

![helix logo](docs/helix_logo.png)

The `@helixml/apps-client` is the client library to interact with apps hosted on [Helix Cloud](https://tryhelix.ai).

### Installation

To use the `@helixml/apps-client` in your project, install it via npm:

```bash
npm install @helixml/apps-client
```

or using yarn:

```bash
yarn add @helixml/apps-client
```

### Usage

Import and use the `AppClient` component in your React application:

```jsx
import { useCallback } from 'react';
import AppClient from '@helixml/apps-client';

const app = AppClient({
  // this api token is for a Helix app that has been linked to github.
  token: 'APP_API_TOKEN',
})

function App() {
  const handleBackend = useCallback(async () => {
    const result = await app.runScript({
      file_path: '/gptscripts/helloworld.gpt',
      input: 'Oranges',
    });

    if(result.error) {
      throw new Error(result.error);
    } else {
      alert(result.output);
    }
  }, []);

  return (
    <div className="App">
      <button
        onClick={ handleBackend }
      >
        Run a cool GPTScript
      </button>
    </div>
  );
}

export default App;
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
npm package: @helixnetwork/bundle-validator
Description: Syntactically validates bundle structure and signatures.
Latest version: 1.0.0-alpha.7

# @helixnetwork/bundle

Syntactically validates bundle structure and signatures.

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/bundle
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/bundle
```

## API Reference

    
* [bundle-validator](#module_bundle-validator)

    * [~validateSignatures(bundle)](#module_bundle-validator..validateSignatures)

    * [~isBundle(bundle)](#module_bundle-validator..isBundle)


<a name="module_bundle-validator..validateSignatures"></a>

### *bundle-validator*~validateSignatures(bundle)

| Param | Type |
| --- | --- |
| bundle | <code>Array.&lt;Transaction&gt;</code> | 

Validates all signatures of a bundle.

<a name="module_bundle-validator..isBundle"></a>

### *bundle-validator*~isBundle(bundle)

| Param | Type |
| --- | --- |
| bundle | <code>Array.&lt;Transaction&gt;</code> | 

Checks if a bundle is _syntactically_ valid.
Validates signatures and overall structure.
npm package: @helixnetwork/checksum
Description: Add, remove and validate checksums
Latest version: 1.0.0-alpha.7

# @helixnetwork/checksum

Add, remove and validate checksums.

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/checksum
```

or using [yarn](https://yarnpkg.com/):

``` yarn
yarn add @helixnetwork/checksum
```

## API Reference

    <a name="module_checksum..isValidChecksum"></a>

### *checksum*~isValidChecksum(addressWithChecksum)

| Param | Type |
| --- | --- |
| addressWithChecksum | <code>string</code> | 


Validates the checksum of the given address txs.
npm package: @helixnetwork/extract-json
Description: Extracts JSON encoded messages from signature message fragments
Latest version: 1.0.0-alpha.7

# @helixnetwork/extract-json

Extracts JSON encoded messages from signature message fragments.

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/extract-json
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/extract-json
```

## API Reference

    <a name="module_extract-json..extractJson"></a>

### *extract-json*~extractJson(bundle)

| Param | Type |
| --- | --- |
| bundle | <code>array</code> | 

Takes a bundle as input and from the signatureMessageFragments extracts the correct JSON
data which was encoded and sent with the transaction.
Supports the following forms of JSON encoded values:
- `"{ \"message\": \"hello\" }"\`
- `"[1, 2, 3]"`
- `"true"`, `"false"` & `"null"`
- `"\"hello\""
- `123`

**Example**  
```js
try {
  const msg = JSON.parse(extractJson(bundle))
} catch (err) {
  err.msg == errors.INVALID_BUNDLE
  // Invalid bundle or invalid encoded JSON
}
```
**Example**  
Example with `getBundle`:

```js
getBundle(tailHash)
  .then(bunlde => {
     const msg = JSON.parse(extractJson(bundle))
     // ...
  })
  .catch((err) => {
     // Handle network & extraction errors
  })
```
npm package: @helixnetwork/http-client
Description: Send commands to a helix node over HTTP.
Latest version: 1.0.0-alpha.7

# @helixnetwork/http-client

Sends commands to [`helix`](https://github.com/iotaledger/iri) over `HTTP`.
Allows to create a network provider compatible with functions in [`@helixnetwork/core`](../core).

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/http-client
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/http-client
```

## API Reference

    
* [http-client](#module_http-client)

    * _static_
        * [.send(command, [uri], [apiVersion])](#module_http-client.send)

    * _inner_
        * [~send](#module_http-client..send)

        * [~setSettings](#module_http-client..setSettings)

        * [~createHttpClient([settings])](#module_http-client..createHttpClient)


<a name="module_http-client.send"></a>

### *http-client*.send(command, [uri], [apiVersion])
**Fulil**: <code>Object</code> - Response  
**Reject**: <code>Error</code> - Request error  

| Param | Type | Default |
| --- | --- | --- |
| command | <code>Command</code> |  | 
| [uri] | <code>String</code> | <code>http://localhost:14265</code> | 
| [apiVersion] | <code>String</code> \| <code>Number</code> | <code>1</code> | 

Sends an http request to a specified host.

**Returns**: Promise  
<a name="module_http-client..send"></a>

### *http-client*~send

| Param | Type |
| --- | --- |
| command | <code>object</code> | 

**Returns**: <code>object</code> - response  
<a name="module_http-client..setSettings"></a>

### *http-client*~setSettings

| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [settings] | <code>object</code> | <code>{}</code> |  |
| [settings.provider] | <code>string</code> | <code>&quot;http://localhost:14265&quot;</code> | Uri of helix node |
| [settings.apiVersion] | <code>string</code> \| <code>number</code> | <code>1</code> | Helix Api version to be sent as `X-HELIX-API-Version` header. |
| [settings.requestBatchSize] | <code>number</code> | <code>1000</code> | Number of search values per request. |

<a name="module_http-client..createHttpClient"></a>

### *http-client*~createHttpClient([settings])

| Param | Type | Default | Description |
| --- | --- | --- | --- |
| [settings] | <code>object</code> | <code>{}</code> |  |
| [settings.provider] | <code>string</code> | <code>&quot;http://localhost:14265&quot;</code> | Uri of helix node |
| [settings.timeout] | <code>number</code> | <code></code> | Timeout |
| [settings.apiVersion] | <code>string</code> \| <code>number</code> | <code>1</code> | Helix Api version to be sent as `X-HELIX-API-Version` header. |
| [settings.requestBatchSize] | <code>number</code> | <code>1000</code> | Number of search values per request. |

Create an http client to access helix http API.

**Returns**: Object
npm package: @helixnetwork/ipfs
Description: ## Installation
Latest version: 1.0.0-alpha.7

# @helixnetwork/ipfs

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/ipfs
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/ipfs
```
npm package: @helixnetwork/multisig
Description: Methods for generating multisig addresses and co-schnorr transactions.
Latest version: 1.0.0-alpha.8

# @helixnetwork/multisig

Methods for generating multisig addresses ansd co-schnorr transactions.

> **Please note that this multisig package is not finalized yet and is subject to breaking changes.**

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/multisig
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/multisig
```

## API Reference

    
* [multisig](#module_multisig)

    * [.Address](#module_multisig.Address)

    * [.Multisig](#module_multisig.Multisig)


<a name="module_multisig.Address"></a>

### *multisig*.Address
<a name="module_multisig.Multisig"></a>

### *multisig*.Multisig
npm package: @helixnetwork/rsa
Description: ## Installation
Latest version: 1.0.0-alpha.7

# @helixnetwork/rsa

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/rsa
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/rsa
```
npm package: @helixnetwork/sha3
Description: Sha3 Library.
Latest version: 1.0.0-alpha.7

# @helixnetwork/sha3

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/sha3
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/sha3
```
npm package: @helixnetwork/transaction
Description: Utilities and validators for transactions.
Latest version: 1.0.0-alpha.7

# @helixnetwork/transaction

Utilities and validators for transactions.

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/transaction
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/transaction
```

## API Reference

    
* [transaction](#module_transaction)

    * [~transactionHash(txBytes)](#module_transaction..transactionHash)

    * [~isTransaction(tx)](#module_transaction..isTransaction)

    * [~isTailTransaction(transaction)](#module_transaction..isTailTransaction)

    * [~isTransactionHash(hash, mwm)](#module_transaction..isTransactionHash)

    * [~isTransactionTxHex(txs, minWeightMagnitude)](#module_transaction..isTransactionTxHex)

    * [~isAttachedTxHex(txs)](#module_transaction..isAttachedTxHex)

<a name="module_transaction..transactionHash"></a>

### *transaction*~transactionHash(txByte)

| Param | Type | Description |
| --- | --- | --- |
| txBytes | <code>TxBytes</code> | TxBytes of 32 transaction bytes |

Calculates the transaction hash out of 768 transaction bytes.

**Returns**: <code>Hash</code> - Transaction hash  
<a name="module_transaction..isTransaction"></a>

### *transaction*~isTransaction(tx)

| Param | Type |
| --- | --- |
| tx | <code>object</code> | 

Checks if input is valid transaction object.

<a name="module_transaction..isTailTransaction"></a>

### *transaction*~isTailTransaction(transaction)

| Param | Type |
| --- | --- |
| transaction | <code>object</code> | 

Checks if given transaction object is tail transaction.
A tail transaction is one with `currentIndex=0`.

<a name="module_transaction..isTransactionHash"></a>

### *transaction*~isTransactionHash(hash, mwm)

| Param | Type |
| --- | --- |
| hash | <code>string</code> | 
| mwm | <code>number</code> | 


Checks if input is correct transaction hash (32 txs)

<a name="module_transaction..isTransactionTxHex"></a>

### *transaction*~isTransactionTxHex(txs, minWeightMagnitude)

| Param | Type |
| --- | --- |
| txs | <code>string</code> | 
| minWeightMagnitude | <code>number</code> | 

Checks if input is correct transaction txs (1536 txs)


<a name="module_transaction..isAttachedTxHex"></a>

### *transaction*~isAttachedTxHex(txs)

| Param | Type |
| --- | --- |
| txs | <code>string</code> | 

Checks if input is valid attached transaction txs.
For attached transactions attached timestamp should not be zero.
npm package: @helixnetwork/transaction-converter
Description: Converts transaction strings (in hexadecimal representation) to transaction objects and back.
Latest version: 1.0.0-alpha.7

# @helixnetwork/transaction-converter

Methods for calculating transaction hashes and converting transaction objects to transaction txs and back.

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/transaction-converter
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/transaction-converter
```

## API Reference

    
* [transaction-converter](#module_transaction-converter)

    * [~asTransactionStrings(transactions)](#module_transaction-converter..asTransactionStrings)

    * [~asTransactionObject(txs)](#module_transaction-converter..asTransactionObject)

    * [~asTransactionObjects([hashes])](#module_transaction-converter..asTransactionObjects)

    * [~transactionObjectsMapper(txs)](#module_transaction-converter..transactionObjectsMapper)


<a name="module_transaction-converter..asTransactionStrings"></a>

### *transaction-converter*~asTransactionStrings(transactions)

| Param | Type | Description |
| --- | --- | --- |
| transactions | <code>Transaction</code> | <code>Array.&lt;Transaction&gt;</code> | Transaction object(s) |

Converts a transaction object or a list of those into transaction strings (txs).

**Returns**: <code>TxHex</code> \| <code>Array.&lt;TxHex&gt;</code> - Transaction strings  
<a name="module_transaction-converter..asTransactionObject"></a>

### *transaction-converter*~asTransactionObject(txs)

| Param | Type | Description |
| --- | --- | --- |
| txs | <code>TxHex</code> | Transaction txs |

Converts transaction txs of 1536 txs into a transaction object.

**Returns**: <code>Transaction</code> - Transaction object  
<a name="module_transaction-converter..asTransactionObjects"></a>

### *transaction-converter*~asTransactionObjects([hashes])

| Param | Type | Description |
| --- | --- | --- |
| [hashes] | <code>Array.&lt;Hash&gt;</code> | Optional list of known hashes. Known hashes are directly mapped to transaction objects, otherwise all hashes are being recalculated. |


Converts a list of transaction txs into list of transaction objects.
Accepts a list of hashes and returns a mapper. In cases hashes are given,
the mapper function map them to converted objects.

**Returns**: <code>function</code> - [`transactionObjectsMapper`](#module_transaction.transactionObjectsMapper)  
<a name="module_transaction-converter..transactionObjectsMapper"></a>


### *transaction-converter*~transactionObjectsMapper(txs)

| Param | Type | Description |
| --- | --- | --- |
| txs | <code>Array.&lt;TxHex&gt;</code> | List of transaction txs to convert |

Maps the list of given hashes to a list of converted transaction objects.

**Returns**: <code>Array.&lt;Transaction&gt;</code> - List of transaction objects with hashes
npm package: @helixnetwork/unit-converter
Description: Converts value across different Helix units.
Latest version: 1.0.0-alpha.7

# @helixnetwork/unit-converter

Converts value across different Helix units.

## Installation

Install using [npm](https://www.npmjs.org/):
```
npm install @helixnetwork/unit-converter
```

or using [yarn](https://yarnpkg.com/):

```
yarn add @helixnetwork/unit-converter
```

## API Reference

    <a name="module_unit-converter..convertUnits"></a>

### *unit-converter*~convertUnits(value, fromUnit, toUnit)

| Param | Type | Description |
| --- | --- | --- |
| value | <code>string</code> \| <code>int</code> \| <code>float</code> |  |
| fromUnit | <code>string</code> | Name of original value unit |
| toUnit | <code>string</code> | Name of unit wich we convert to |

Converts accross Helix units. Valid unit names are:
`h`, `Kh`, `Mh`, `Gh`, `Th`, `Ph`
npm package: @helixpay-xyz/helix
Description: CLI Wallet to interact with Helixpay protocol
Author: @helixpay-xyz
Latest version: 1.8.0

# Helixpay CLI
CLI Wallet to interact with Helixpay protocol.

## Usage

Install helix globally

```
npm install -g @helixpay-xyz/helix
```

Open helix wallet

```
helix
```

## Running the tests

```
npm run test
```

## Linting

```
npm run lint
```

## Contributing

Please read [CONTRIBUTING.md](https://gist.github.com/PurpleBooth/b24679402957c63ec426) for details on our code of conduct, and the process for submitting pull requests to us.

## License

This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details