open-index/open-npm huggingface dataset:
npm package: @mosquetero/math-utils
Description: A simple math utility library for addition, subtraction, multiplication, and division.
Author: Fredy Herrera
Latest version: 1.0.1

# Math Utils

Una librería simple de utilidades matemáticas para operaciones básicas: suma, resta, multiplicación y división.

## 📦 Instalación

```bash
npm install @mosquetero/math-utils
```

O si prefieres clonar el repositorio:

```bash
git clone <repository-url>
cd librarys
```

## 🚀 Uso

### Importación individual

```javascript
import { add, subtract, multiply, divide } from '@mosquetero/math-utils';

// Suma
const resultado = add(5, 3);
console.log(resultado); // 8

// Resta
const diferencia = subtract(10, 4);
console.log(diferencia); // 6

// Multiplicación
const producto = multiply(3, 4);
console.log(producto); // 12

// División
const cociente = divide(20, 4);
console.log(cociente); // 5
```

### Importación por defecto

```javascript
import mathUtils from '@mosquetero/math-utils';

console.log(mathUtils.add(2, 3));      // 5
console.log(mathUtils.subtract(10, 3)); // 7
console.log(mathUtils.multiply(4, 5));  // 20
console.log(mathUtils.divide(15, 3));   // 5
```

## 📚 API

### `add(a, b)`

Suma dos números.

**Parámetros:**
- `a` (number): Primer número
- `b` (number): Segundo número

**Retorna:** (number) La suma de `a` y `b`

**Ejemplo:**
```javascript
add(2, 3); // 5
```

### `subtract(a, b)`

Resta el segundo número del primero.

**Parámetros:**
- `a` (number): Primer número (minuendo)
- `b` (number): Segundo número (sustraendo)

**Retorna:** (number) La diferencia de `a` y `b`

**Ejemplo:**
```javascript
subtract(5, 3); // 2
```

### `multiply(a, b)`

Multiplica dos números.

**Parámetros:**
- `a` (number): Primer número
- `b` (number): Segundo número

**Retorna:** (number) El producto de `a` y `b`

**Ejemplo:**
```javascript
multiply(4, 3); // 12
```

### `divide(a, b)`

Divide el primer número por el segundo.

**Parámetros:**
- `a` (number): Primer número (dividendo)
- `b` (number): Segundo número (divisor)

**Retorna:** (number) El cociente de `a` y `b`

**Lanza:** (Error) Si el divisor es cero

**Ejemplo:**
```javascript
divide(10, 2); // 5

// División por cero
divide(10, 0); // Error: Division by zero is not allowed
```

## 🧪 Tests

Para ejecutar los tests de la librería:

```bash
npm test
```

O directamente con Node.js:

```bash
node src/index.test.js
```

Los tests cubren todas las funciones matemáticas incluyendo casos edge como:
- Números positivos y negativos
- Números decimales
- División por cero (validación de error)
- Exportación individual y por defecto

## 🛠️ Desarrollo

Esta librería utiliza módulos ES6 (`type: "module"`), por lo que es compatible con Node.js 14+ y navegadores modernos que soporten ES modules.

## 📝 Licencia

MIT

## 👤 Autor

Fredy Herrera

## 🔑 Palabras Clave

math, addition, subtraction, multiplication, division, utility
npm package: @moss-hub/mossy
Description: mossy contracts for typescript
Author: Alexandas
Latest version: 0.0.6

![License: GPL](https://img.shields.io/badge/license-GPLv3-blue)![Version Badge](https://img.shields.io/badge/version-0.0.2-lightgrey.svg)
# Mossy

## Install

`npm install`

## Local development

`npm run build`

`npx hardhat node`

## Get start

1. create `.env` file  and set your mnemonic as below

   `MNEMONIC="your mnemonic"`

2. compile contracts, it will generate contract artifacts also typechains

   `yarn build`

3. test contracts

   `yarn test`

---

Once the rpc url is unavailable, check it [here](https://chainlist.org/)
npm package: @moss-labs/scw-connector
Description: Moss Smart Contract Wallet connector (EOA pays gas, expose SCW)
Author: Moss Labs
Latest version: 0.1.5

# @moss-labs/scw-connector

Moss Smart Contract Wallet connector for wagmi/RainbowKit.

- Expose SCW (smart contract wallet) address to dApps
- Wrap `from=SCW` tx into `EOA -> SCW.execute(...)` (EOA pays gas)
- Return ERC‑1271 wrapped signatures (outer EIP‑712) for `personal_sign` / `eth_signTypedData*`
- Detect multi-nonce deployments (scan `computeSmartWalletAddress(owner, nonce)`)
- Registry-aware helpers (`getSystemApps`, `isLogicUsable`) mirror Moss gating rules
- Provider-first RPC strategy avoids chain mismatch between wallet + configured RPC

## Install

```bash
npm i @moss-labs/scw-connector
# peer deps (in your app)
npm i wagmi viem @rainbow-me/rainbowkit ethers @tanstack/react-query
```

## Usage

```ts
import { createConfig, http, WagmiConfig } from 'wagmi'
import { RainbowKitProvider, ConnectButton, lightTheme } from '@rainbow-me/rainbowkit'
import { createMossConnector, MossAccountOSSDK } from '@moss-labs/scw-connector'

const moss = createMossConnector({
  getOwnerProvider: () => (typeof window !== 'undefined' ? (window as any).ethereum : undefined),
  sdkConfig: {
    rpcUrl: 'https://eth-sepolia.g.alchemy.com/v2/KEY',
    chainId: 11155111,
    contracts: {
      factory: '0x...', implementation: '0x...', registry: '0x...'
    },
  },
})

const config = createConfig({
  chains: [/* your chains */],
  transports: {/* ... */},
  connectors: [moss as any],
})
```

```tsx
<WagmiConfig config={config}>
  <RainbowKitProvider theme={lightTheme({ accentColor: '#f9a8d4' })}>
    <ConnectButton chainStatus={{ smallScreen: 'icon', largeScreen: 'full' }}
                   accountStatus={{ smallScreen: 'avatar', largeScreen: 'full' }}
                   showBalance={{ smallScreen: false, largeScreen: true }} />
  </RainbowKitProvider>
</WagmiConfig>
```

## SDK (non‑4337)

```ts
import { MossAccountOSSDK } from '@moss-labs/scw-connector'

const sdk = new MossAccountOSSDK({ rpcUrl, chainId, contracts })
const scw = await sdk.getSmartWalletAddress(eoa)
const exists = await sdk.checkSmartWalletExists(scw)

// Probe multiple deterministic addresses (nonce 0..3 for example)
const predicted = await Promise.all([0, 1, 2, 3].map((nonce) => sdk.computeSmartWalletAddress(eoa, nonce)))

// Registry helpers so your UI can validate logic contracts
const systemApps = await sdk.getSystemApps()
const canUse = await sdk.isLogicUsable({ smartWallet: scw, logic: '0xlogic' })
```

## License

MIT
npm package: @moss-tools/mcp-server
Description: MCP server exposing MOSS semantic search and index management as tools.
Author: Moss Team
Latest version: 1.0.0-beta.2

# @moss-tools/mcp-server

MCP (Model Context Protocol) server that exposes [MOSS](https://Moss.dev) semantic search and index management as tools for any MCP-compatible client.

Queries automatically load indexes into memory on first use, giving <10ms local latency instead of ~1s cloud round-trips.

## Quick Start

### Claude Desktop

Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "moss": {
      "command": "npx",
      "args": ["-y", "@moss-tools/mcp-server"],
      "env": {
        "MOSS_PROJECT_ID": "your-project-id",
        "MOSS_PROJECT_KEY": "your-project-key"
      }
    }
  }
}
```

### Direct Usage

```bash
MOSS_PROJECT_ID=your-id MOSS_PROJECT_KEY=your-key npx @moss-tools/mcp-server
```

## Environment Variables

| Variable | Required | Description |
|----------|----------|-------------|
| `MOSS_PROJECT_ID` | Yes | Your MOSS project ID |
| `MOSS_PROJECT_KEY` | Yes | Your MOSS project key |

## How Querying Works

The `query` tool automatically loads the index into memory on the first call for each index. This means:

1. **First query** -- downloads the index locally (~1-2s one-time cost), then runs the query locally
2. **Subsequent queries** -- run entirely in-memory at <10ms latency

The server tracks which indexes are loaded and skips the download on repeat queries. Use `load_index` to pre-load specific indexes ahead of time and avoid the first-query latency. Mutations (`add_docs`, `delete_docs`, `delete_index`) invalidate the local copy so the next query re-downloads fresh data.

## Tools

| Tool | Description |
|------|-------------|
| `create_index` | Create a new index with documents |
| `add_docs` | Add documents to an existing index |
| `delete_docs` | Delete documents by ID |
| `load_index` | Pre-load an index into memory for fast local queries |
| `query` | Semantic search (auto-loads index locally, <10ms after first load) |
| `list_indexes` | List all indexes in the project |
| `get_index` | Get metadata for an index |
| `delete_index` | Delete an index |
| `get_docs` | Retrieve documents from an index |
| `get_job_status` | Check status of an async job |

## Programmatic Usage

```typescript
import { createMossMcpServer, MossClient } from "@moss-tools/mcp-server";
import { MossClient as MossSdkClient } from "@inferedge/moss";

const restClient = new MossClient({
  projectId: "your-id",
  projectKey: "your-key",
});
const sdkClient = new MossSdkClient("your-id", "your-key");

const server = createMossMcpServer(restClient, sdkClient);
// Connect to any MCP transport
```

## License

MIT
npm package: @mossop/config
Description: Shared configurations for my projects
Author: Dave Townsend
Latest version: 2.1.1

# @mossop/config

This is an attempt to put common parts of my JavaScript project configuration
into a shared location. Other than `base` each directory is a different
configuration set:

* `node-ts`: Modules that use TypeScript in a node environment.
* `vscode-ts`: VS Code extensions written in TypeScript.
* `web-ts`: Web apps written in TypeScript.
* `react-ts`: React apps written in TypeScript.
* `react-native-ts`: React Native apps written in TypeScript.
* `remix-ts`: Remix apps written in TypeScript.
npm package: @most/adapter
Description: Mostjs emphasizes declarative event streams, which have many advantages, such as helping to avoid race conditions.  However, getting data into a mostjs event stream graph from 3rd party libraries that weren't designed with that approach in mind can be tri
Author: Brian Cavalier
Latest version: 1.0.0

# @most/adapter

Mostjs emphasizes declarative event streams, which have many advantages, such as helping to avoid race conditions.  However, getting data into a mostjs event stream graph from 3rd party libraries that weren't designed with that approach in mind can be tricky.  Often, trying to force a library into that model leads to a messy solution.

Most-adapter provides a disciplined imperative API for getting external data into a mostjs stream, with the goal of making it simpler to integrate libraries that don't lend themselves to a declarative approach.

## API

### Adapter

```js
type Adapter<A, B = A> = [(event: A) => void, Stream<B>]
```

An adapter is an entangled pair of an event stream, and a function to induce
(cause) events in that stream.

### createAdapter :: () &rarr; Adapter<A>

Create an Adapter.

```js
const [induce, events] = createAdapter<string>()

induce('hello') // cause an event with value "hello" to occur in events
induce('world') // cause an event with value "world" to occur in events
```
npm package: @most/animation-frame
Description: [![Build Status](https://travis-ci.org/mostjs/x-animation-frame.svg?branch=master)](https://travis-ci.org/mostjs/x-animation-frame)
Author: Brian Cavalier
Latest version: 0.1.1

[![Build Status](https://travis-ci.org/mostjs/x-animation-frame.svg?branch=master)](https://travis-ci.org/mostjs/x-animation-frame)

**EXPERIMENTAL** This is an experimental package.

# @most/animation-frame

Create a stream of animation frames.

## Get it

`npm i @most/animation-frame --save`

`yarn add @most/animation-frame`

## Types

```js
export type DOMHighResTimeStamp = number

export type AnimationFrameHandler = DOMHighResTimeStamp => void

export type AnimationFrameRequest = number

export type AnimationFrames = {
  requestAnimationFrame: AnimationFrameHandler => AnimationFrameRequest,
  cancelAnimationFrame: AnimationFrameRequest => void
}
```

Note that `window` satisfies the `AnimationFrames` type, so you can pass `window` to the API methods below.

## API

### nextAnimationFrame :: AnimationFrames &rarr; Stream DOMHighResTimeStamp

Create a stream containing only the _next_ animation frame.

### animationFrames :: AnimationFrames &rarr; Stream DOMHighResTimeStamp

Create an infinite stream containing all future animation frames.  This can be used to efficiently update a UI on each animation frame.  Use [`take`](http://mostcore.readthedocs.io/en/latest/api.html#take), [`until`](http://mostcore.readthedocs.io/en/latest/api.html#until), etc. to make the stream finite if you need.

```js
import { animationFrames } from '@most/animation-frame'
import { tap, sample, runEffects } from '@most/core'
import { newDefaultScheduler } from '@most/scheduler'

const afs = animationFrames(window)
const applicationUpdates = createApplicationUpdatesStream()

// Sample updates at each animationFrame and render the UI
const render = tap(renderUpdates, sample(applicationUpdates, afs))

runEffects(render, newDefaultScheduler())
npm package: @most/dom-event
Description: Streamlined DOM Events for most.js
Author: brian@hovercraftstudios.com
Latest version: 2.2.0

# most dom-event

Streamlined DOM events for [@most/core](https://github.com/mostjs/core). Now you can write:

```js
import { click } from '@most/dom-event';
import { tap, runEffects } from "@most/core";
import { newDefaultScheduler } from "@most/scheduler";

const clickStream = click(el);

runEffects(tap(console.log, clickStream), newDefaultScheduler());
```

## Install

`npm install --save @most/dom-event`

## API

### Events

#### &lt;eventName&gt; :: (EventTarget t, Event e) => t &rarr; boolean=false &rarr; Stream e

See [the source](src/index.js) for all the supported event names. Each has the general signature:

```js
const stream = eventName(domNode, useCapture = false);
```

### domEvent

#### domEvent :: (EventTarget t, Event e) => String &rarr; t &rarr; boolean=false &rarr; Stream e

If there's an event type that isn't supported, you can use the general `domEvent` API:

```js
const stream = domEvent(eventName, domNode, useCapture = false);
```
npm package: @most/eslint-config-most
Description: eslint-config-most
Author: Brian Cavalier
Latest version: 1.0.3

# mostjs ESLint config

## Usage

### Via package-starter

Use the [package-starter](https://github.com/mostjs/package-starter).

### Via eslintrc

If you don't use the package starter, you can extend `eslint-config-most` in your .eslintrc:

```
npm install --save-dev @most/eslint-config-most
```

```js
{
  'extends': '@most/eslint-config-most'
}
```

(Note: You can omit the `eslint-config-` prefix since it is automatically assumed by ESLint)

You can override settings by adding them directly into your .eslintrc file.
npm package: @most/fluent
Description: [![Build Status](https://travis-ci.org/mostjs/x-fluent.svg?branch=master)](https://travis-ci.org/mostjs/x-fluent)
Author: Brian Cavalier
Latest version: 0.1.0

[![Build Status](https://travis-ci.org/mostjs/x-fluent.svg?branch=master)](https://travis-ci.org/mostjs/x-fluent)

**EXPERIMENTAL** This is an experimental package.

# @most/fluent

Use `@most/core` with a fluent API.  `@most/fluent` wraps a `@most/core` Stream in a FluentStream type that provides `thru` and `to` methods for dot-chaining.

## Get it

`npm i @most/fluent --save`

`yarn add @most/fluent`

## Example

```js
import { change } from `@most/dom-event`
import { map, filter } from `@most/core`
import { fluently } from `@most/fluent`

const changes = change(inputElement)

// Wrap a @most/core stream of change events and fluently
// map change events to their associated input value, and
// retain only non-empty values
const changesFluent = fluently(changes)
  .thru(map(e => e.target.value))
  .thru(filter(value => value.length > 0))
```

## Types

### FluentStream

A FluentStream is a [Stream](http://mostcore.readthedocs.io/en/latest/api.html#stream) with two additional methods that enable fluent (dot-chaining) usage.

```js
type FluentStream<A> = Stream<A> & {
  thru <B> (f: (Stream<A>) => Stream<B>): FluentStream<B>
  apply <B> (f: (Stream<A>) => B): B
}
```

## API

### fluently :: Stream a &rarr; FluentStream a

Wrap a `@most/core` Stream in a FluentStream.

### FluentStream methods

#### thru :: FluentStream a ~> (Stream a &rarr; Stream b) &rarr; FluentStream b

Apply functions fluently to a Stream, wrapping the result in a FluentStream.  Use `thru` when you want to continue dot-chaining other Stream operations.

#### apply :: FluentStream a ~> (Stream a &rarr; b) &rarr; b

Apply functions fluently to a Stream, _without_ re-wrapping the result.  Use `apply` to return something other than a Stream.
npm package: @most/hold
Description: Emit latest event to new observers
Author: brian@hovercraftstudios.com
Latest version: 4.1.0

# @most hold()

Deliver the most recently seen event to each new observer the instant it begins observing.  A held stream is always multicast.

**Note**: `@most/hold` >= 3.0.0 is compatible with [`@most/core`](http://mostcore.readthedocs.io/en/latest/).  Use `@most/hold` 2.x for compatibility with [`most`](https://github.com/cujojs/most/releases) 1.x.

## Install

`npm install --save @most/hold`

## Usage

```js
import { click } from '@most/dom-event'
import { map } from '@most/core'
import { hold } from '@most/hold'

const clickCoords = map(e => ({ x: e.clientX, y: clientY }), click(document))

// start holding on first subscription
const heldCoords = hold(clickCoords)
```

## API

### hold :: Stream a &rarr; Stream a

Given an input stream:

```
stream:    -a---b---c---d->
```

observers which begin observing at different times will see:

```
observer1: -a---b---c---d->
observer2:    a-b---c---d->
observer3:           c--d->
```
npm package: @most/multicast
Description: Efficient stream sharing for most.js
Author: Tylor Steinberer
Latest version: 1.3.0

# ⚠️ Deprecated ⚠️
 
`@most/multicast` is deprecated.

Support and maintenance will cease when `@most/core` 1.0 is released. Meanwhile, only critical bug fixes will be released. 

Its functionality is currently available in [@most/core](http://mostcore.readthedocs.io/en/latest/api.html#multicast) and will also be available in most 2.0.

# @most/multicast

Efficient source sharing of an underlying stream to multiple observers.

## API

### multicast :: Stream a &rarr; Stream a
Returns a stream equivalent to the original, but which can be shared more efficiently among multiple consumers.

```
stream:             -a-b-c-d->
multicast(stream):  -a-b-c-d->
```

Using multicast allows you to build up a stream of maps, filters, and other transformations, and then share it efficiently with multiple observers.
npm package: @most/sample
Description: @most/sample
Author: Tylor Steinberger
Latest version: 1.1.0

# @most/sample

Create a new stream by combining sampled values from many input streams.

## Install

`npm install @most/sample`

## API

#### sample :: (a → b → c) → Stream a → Stream b → Stream c

```
stream:                          -2--3-4--2--5--6---7---1->
sampler:                         ---1----2----3-------5--->
sample(sum, sampler, stream):    ---3----6----8-------12-->
```
`sample` produces a value only when an event arrives on the sampler,
passing the value of the `sampler` along with the latest value from
`stream`.

`sample` is curried by default.

```js
import {periodic, of} from 'most';
import {sample} from '@most/sample';

const add = (x, y) => x + y;

const sampleWithArray = sample(Array);
const sampleEachSecond = sampleWithArray(periodic(1000, 1).scan(add, 0));

sampleEachSecond(of(2))
  .take(3)
  .observe(([sec, val]) => {
    console.log('Seconds Passed: ' + sec);
    console.log(sec * value);
  });
// Seconds Passed: 0
// 0
// Seconds Passed: 1
// 2
// Seconds Passed: 2
// 4

```

#### sampleArray :: (a → [b] → c) → Stream a → [Stream b] → Stream c

```
s1:                             -2--3-4--2--5--6---7---1->
s2:                             -1--2---3----------4----->
sampler:                        ---1----2----3-------5--->
sample(sum, sampler, [s1, s2]): ---4----9----11-------16-->
```
`sampleArray` produces a value only when an event arrives on the sampler,
passing the value of the `sampler` along with an array of latest values from
streams contained in `arrayOfStreams`.

`sampleArray` is curried by default.

```js
import {periodic, of} from 'most';
import {sampleArray} from '@most/sample';

const add = (x, y) => x + y;

const sampleWithArray = sampleArray(Array);
const sampleEachSecond = sampleWithArray(periodic(1000, 1).scan(add, 0));

sampleEachSecond([of(1), of(2)])
  .take(3)
  .observe(([sec, [s1, s2]]) => {
    console.log('Seconds Passed: ' + sec);
    console.log(s1 * sec, s2 * sec);
  });
// Seconds Passed: 0
// 0, 0
// Seconds Passed: 1
// 1, 2
// Seconds Passed: 2
// 2, 4

```
npm package: @most/xhr
Description: XHR with @most/core
Author: brian@briancavalier.com
Latest version: 0.1.0

[![Build Status](https://travis-ci.org/briancavalier/most-xhr.svg?branch=master)](https://travis-ci.org/briancavalier/most-xhr)

# @most/xhr

Make XMLHttpRequests with [`@most/core`](http://mostcore.readthedocs.io/en/latest/).  Provide a function to setup the XMLHttpRequests however you want/need and get back a Stream containing the `load` (or `error`, or `timeout`) event.

## Get it

`npm i @most/xhr --save`

`yarn add @most/xhr`

## API

### request :: (() &rarr; XMLHttpRequest) &rarr; Stream ProgressEvent

Provide a function to setup the XMLHttpRequest however you need (e.g. setting request headers, etc.), but don't call `.send()`. Running the Stream will invoke the function, send the returned XMLHttpRequest, handle events, and call `.abort()` when necessary.

The returned Stream will contain at most 1 event: the ProgressEvent emitted by XMLHttpRequest's `load`, `error`, or `timeout` events.

```js
import { request } from '@most/xhr'

const responseStream = request(() => {
  const xhr = new XMLHttpRequest()
  xhr.responseType = 'json'
  xhr.open('GET', 'https://...', true)
  return xhr
})
```

## Handling errors

By default, the returned stream _does not_ fail for errors or for successful HTTP requests whose status is >= 300.  This allows you to handle error events and HTTP status codes in whatever way is best for your application.

If you need, you can detect errors and turn them into Stream failures using `chain()`:

```js
import { request } from '@most/xhr'
import { chain, now, throwError } from '@most/core'

const responseStream = request(() => {
  const xhr = new XMLHttpRequest()
  // setup xhr ...
  return xhr
})

const failOnError = progressEvent =>
  progressEvent.type === 'error'
  ? throwError(new Error(...))
  : now(progressEvent)

const failOnErrorStream = chain(failOnError, responseStream)
```