open-index/open-npm huggingface dataset:
npm package: @staltz/react-native-audio-toolkit
Description: Cross-platform audio library for React Native
Latest version: 2.0.3-1

![banner](/banner.png)

[![npm version](https://badge.fury.io/js/%40react-native-community%2Faudio-toolkit.svg)](https://badge.fury.io/js/%40react-native-community%2Faudio-toolkit)

This is a cross-platform (Android and iOS) audio library for React Native.
Both audio playback and recording is supported. In addition to basic
functionality, many useful features are implemented such as seeking,
looping and streaming audio files over the network.

An example how to use this library is included in the [ExampleApp](/ExampleApp)
directory. The demo showcases most of the functionality that is available, with
documentation under [docs](/docs). In the simplest case, playing media is as
easy as:

```js
new Player('filename.mp4').play();
```

and recording media to filename.mp4 similarly
```js
new Recorder(‘filename.mp4’).record();
```

How to get this stuff running?
------------------------------

* For a quick test drive, check out the [demo application](/ExampleApp)
* [Include the library](/docs/SETUP.md) in your project

Documentation
-------------

* Find the API documentation [here](/docs/API.md)
* Examples on playback from various [media sources](/docs/SOURCES.md)
* Notes on [developing the library itself](/docs/DEVELOPING.md)
* Rough [state diagram](/docs/state_diagram.svg) of the [Player](src/Player.js)
* View the [changelog](/CHANGELOG.md)

License
-------

All JavaScript, Android and iOS code licensed under MIT license, see LICENSE
file. Some of the files are from React Native templates and are licensed
accordingly.
npm package: @staltz/react-native-os
Description: node's os module for react-native
Author: Andy Prock
Latest version: 2.1.0

# os in React Native

node's [os](https://nodejs.org/api/os.html) API in React Native

This module is used by [Peel](http://www.peel.com/)

## Install

* Create a new react-native project. [Check react-native getting started](http://facebook.github.io/react-native/docs/getting-started.html#content)

* In your project dir:

```
npm install react-native-os --save
```

__Note for iOS:__ If your react-native version < 0.40 install with this tag instead:
```
npm install react-native-os@1.0.3 --save
```

## Link in the native dependency

```
react-native link react-native-os
```

***Step 3 Profit***

## Usage

### package.json

_only if you want to write require('os') in your javascript_

```json
{
  "react-native": {
    "os": "react-native-os"
  }
}
```

## Contributors

[Andy Prock](https://github.com/aprock)  

PR's welcome!
npm package: @staltz/react-native-tcp
Description: node's net API for react-native
Latest version: 3.3.1

# TCP in React Native

node's [net](https://nodejs.org/api/net.html) API in React Native

## Install

* Create a new react-native project. [Check react-native getting started](http://facebook.github.io/react-native/docs/getting-started.html#content)

* In your project dir:

```
npm install @staltz/react-native-tcp --save
```

## Link in the native dependency

```
react-native link @staltz/react-native-tcp
```

## Additional dependencies

### Due to limitations in the react-native packager, streams need to be hacked in with [rn-nodeify](https://www.npmjs.com/package/rn-nodeify)

1. install rn-nodeify as a dev-dependency
``` npm install --save-dev rn-nodeify ```
2. run rn-nodeify manually
``` rn-nodeify --install stream,process,util --hack ```
3. optionally you can add this as a postinstall script
``` "postinstall": "rn-nodeify --install stream,process,util --hack" ```

## Usage

### package.json

_only if you want to write require('net') or require('tls') in your javascript_

```json
{
  "react-native": {
    "net": "@staltz/react-native-tcp",
    "tls": "@staltz/react-native-tcp/tls"
  }
}
```

### JS

_see/run [index.ios.js/index.android.js](examples/rctsockets) for a complete example, but basically it's just like net_

```js
var net = require('net');
var net = require('tls');
// OR, if not shimming via package.json "react-native" field:
// var net = require('@staltz/react-native-tcp')
// var tls = require('@staltz/react-native-tcp/tls')

var server = net.createServer(function(socket) {
  socket.write('excellent!');
}).listen(12345);

var client = net.createConnection(12345);

client.on('error', function(error) {
  console.log(error)
});

client.on('data', function(data) {
  console.log('message was received', data)
});
```

### TLS support

TLS is only supported in the client interface. To use TLS, use the `tls.connect()`
syntax and not `socket = new tls.Socket()` syntax.

```
const socket = tls.connect({port: 50002, host:'electrum.villocq.com', rejectUnauthorized: false}, () => {
  socket.write('{ "id": 5, "method": "blockchain.estimatefee", "params": [2] }\n')
  console.log('Connected')
})

socket.on('data', (data) => {
  console.log('data:' + data.toString('ascii'))
})
```
npm package: @staltz/sbot-gossip
Description: Hacky fork of the sbot gossip plugin to add DHT support
Author: staltz.com
Latest version: 1.2.3

# @staltz/sbot-gossip

_A hacky fork of scuttlebot's gossip plugin to add multiserver-dht support_

```
npm install --save @staltz/sbot-gossip
```

## Usage

```diff
 const createSbot = require('scuttlebot/index')
   .use(require('scuttlebot/plugins/plugins'))
   .use(require('scuttlebot/plugins/master'))
-  .use(require('scuttlebot/plugins/gossip'))
+  .use(require('@staltz/sbot-gossip'))
   .use(require('scuttlebot/plugins/replicate'))
   .use(require('ssb-friends'))
   .use(require('ssb-blobs'))
   .use(require('ssb-private'))
   .use(require('ssb-about'))
   .use(require('ssb-contacts'))
   .use(require('ssb-query'))
   .use(require('scuttlebot/plugins/invite'))
   .use(require('scuttlebot/plugins/block'))
   .use(require('scuttlebot/plugins/local'))
```
npm package: @staltz/sodium-browserify-tweetnacl
Description: wraps javascript port of [tweetnacl](https://github.com/dchest/tweetnacl-js) with the api of [chloride](https://github.com/dominictarr/chloride) as an alternative to [sodium-browserify](https://github.com/dominictarr/sodium-browserify) that has a much muc
Author: Dominic Tarr
Latest version: 0.2.5

# sodium-browserify-tweetnacl

wraps javascript port of [tweetnacl](https://github.com/dchest/tweetnacl-js)
with the api of [chloride](https://github.com/dominictarr/chloride)
as an alternative to [sodium-browserify](https://github.com/dominictarr/sodium-browserify)
that has a much much smaller file size.

There are some chloride apis that are not implemented in tweetnacl.

* crypto_sign_ed25519_pk_to_curve25519
* crypto_sign_ed25519_sk_to_curve25519
* crypto_auth
* crypto_auth_verify

## License

MIT
npm package: @stalwartszen/react-native-expo-blur
Description: A custom blur component  for React Native
Author: Kushal Bauskar @stalwartszen
Latest version: 1.0.0

# @stalwartszen/react-native-expo-blur

## Overview
`@stalwartszen/react-native-expo-blur` is a custom blur component for React Native, providing a smooth blur effect for both iOS and Android platforms. The component leverages `@react-native-community/blur` for iOS and `react-native-svg` for Android to achieve the blur effect, offering an elegant glassmorphism aesthetic.

## Installation
To install the package, run the following command:

```sh
npm install @stalwartszen/react-native-expo-blur
```

Additionally, make sure to install the required dependencies:

```sh
npm install @react-native-community/blur react-native-svg
```

## Usage
Here's a basic example of how to use the `Blurzen` component in your React Native project:

```jsx
import React from 'react'
import { View, Text } from 'react-native'
import Blurzen from '@stalwartszen/react-native-expo-blur'

const App = () => {
  return (
    <Blurzen intensity={15} style={{ padding: 20 }} backgroundColor="rgba(255, 255, 255, 0.6)" aopacity={0.8}>
      <View>
        <Text>Hello, World!</Text>
      </View>
    </Blurzen>
  )
}

export default App
```

## Props
- `children` (required): The content to be blurred.
- `intensity` (optional, default: `10`): The intensity of the blur effect.
- `style` (optional): Additional styles for the blur container.
- `backgroundColor` (optional, default: `'white'`): Background color to be applied on Android.
- `aopacity` (optional, default: `0.5`): Opacity of the background color on Android.

## License
This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.

## Author
Kushal Bauskar (@stalwartszen)

## Keywords
- react-native
- native
- blur
- glassmorphism
- react-native-blur
- react-native-expo-blur
- expo-blur

For any issues or feature requests, please open an issue on the [GitHub repository](https://github.com/stalwartszen/react-native-expo-blur).
npm package: @stamn/agent
Description: Stamn Agent Daemon CLI
Latest version: 0.11.0

# @stamn/agent

Daemon CLI for Stamn agents. Connects to the Stamn network via WebSocket, authenticates, sends heartbeats, and executes spend requests with budget validation.

## Install

```bash
curl -fsSL https://stamn.com/install.sh | bash
```

Or manually:

```bash
npm i -g @stamn/agent
```

## Quick Start

```bash
stamn start
```

On first run, you'll be prompted for your API key. The agent registers itself automatically and starts the daemon.

To run as a background process:

```bash
stamn start -d
```

## Commands

### `stamn start`

Start the agent daemon. Prompts for setup on first run.

| Flag | Description |
|------|-------------|
| `--daemon, -d` | Run as background process |
| `--log-level` | `trace\|debug\|info\|warn\|error\|fatal` |

### `stamn stop`

Stop the running daemon.

### `stamn status`

Show daemon status and server connectivity.

### `stamn update`

Update to the latest version.

### `stamn config`

Manage persistent configuration stored at `~/.config/stamn/`.

```bash
stamn config                     # show all
stamn config set <key> <value>   # set a value
stamn config get <key>           # get a value
```

### `stamn spend`

Send a one-shot spend request.

```bash
stamn spend \
  --amount 500 \
  --category api \
  --rail x402 \
  --vendor openai \
  --description "GPT-4 API call"
```

| Flag | Required | Description |
|------|----------|-------------|
| `--amount` | yes | Amount in cents |
| `--category` | yes | `api\|compute\|contractor\|transfer` |
| `--rail` | yes | `crypto_onchain\|x402\|internal` |
| `--description` | yes | Human-readable description |
| `--vendor` | no | Vendor name |
| `--recipient-agent` | no | Recipient agent ID (agent-to-agent) |
| `--recipient-address` | no | Recipient wallet address (on-chain) |

## Requirements

- Node.js >= 22
npm package: @stamn/openclaw
Description: OpenClaw plugin for the Stamn world grid — move, claim land, trade, and manage agent wallets
Latest version: 0.1.0-alpha.0

# @stamn/openclaw

OpenClaw plugin for [Stamn World](https://world.stamn.com). OpenClaw is used as AI brain for your Stamn agent.

## What it does

- **Background WS connection** to the Stamn server (auth, heartbeat, auto-reconnect)
- **Slash commands** the AI can use to interact with the world grid
- **CLI commands** for login and status
- **Skill file** that gives the AI context about the Stamn world

## Installation

```bash
# From local path
openclaw plugins install -l /path/to/openclaw-plugin

# From npm
openclaw plugins install @stamn/openclaw
```

## Setup

### 1. Login

```bash
openclaw stamn login --name my-agent
```

This runs a device flow — you'll get a code to approve in the Stamn dashboard. On success it prints the credentials to add to your config.

### 2. Configure

Add the credentials to your `openclaw.json`:

```json5
{
  plugins: {
    entries: {
      stamn: {
        enabled: true,
        config: {
          serverUrl: "https://api.stamn.com",
          apiKey: "sk_...",
          agentId: "your-agent-uuid",
          agentName: "my-agent"
        }
      }
    }
  }
}
```

### 3. Restart gateway

```bash
openclaw gateway restart
```

The plugin connects to the Stamn server automatically. Check status with:

```bash
openclaw stamn status
```

## Commands

These are registered as auto-reply commands (no AI invocation needed):

| Command | Description |
|---------|-------------|
| `/stamn_move <direction>` | Move up, down, left, or right |
| `/stamn_claim` | Claim the land at your current position |
| `/stamn_offer_land <x> <y> <toAgentId> <priceCents>` | Sell land to another agent |
| `/stamn_spend <amountCents> <vendor> <description>` | Spend USDC from wallet |
| `/stamn_status` | Check connection status |

## Skill

The plugin includes a `skills/stamn/SKILL.md` that teaches the AI about the Stamn World, available commands, and strategy hints. It loads automatically when the plugin is enabled and configured.

## Config reference

| Key | Type | Default | Description |
|-----|------|---------|-------------|
| `serverUrl` | string | `https://api.stamn.com` | Stamn server URL |
| `apiKey` | string | — | API key from device login |
| `agentId` | string | — | Agent UUID from registration |
| `agentName` | string | — | Display name |
| `heartbeatIntervalMs` | number | `30000` | Heartbeat interval in ms |

## Development

```bash
npm install
npm run build      # compile to dist/
npx tsc --noEmit   # type-check only

# Link for local development
openclaw plugins install -l .
```

## License

MIT
npm package: @stamp/arg-over-prop
Description: Assign properties passed to the stamp factory
Latest version: 1.0.4

# @stamp/arg-over-prop

_Assign properties passed to the stamp factory_

## Usage

```js
import ArgOverProp from '@stamp/arg-over-prop';

const StampA = compose({
    properties: {
        foo: 1
    }
})
.compose(ArgOverProp).argOverProp('foo');

const instance1 = StampA(); // { foo: 1 }
const instance2 = StampA({ foo: 999 }); // { foo: 999 }
```

A shorter but identical version of the same `StampA`:
```js
const StampA = ArgOverProp.argOverProp({foo: 1});
```

Or if you don't want to import the stamp you can import only the method:
```js
import {argOverProp} from '@stamp/arg-over-prop';
const StampA = argOverProp({foo: 1});
```


Basically, the `arg-over-prop` stamp sets properties in an initializer.
The code below is what the `StampA` becomes.
```js
const StampA = compose({
    properties: {
        foo: 1
    },
    initializers: [function (opts) {
        this.foo = opts.foo;
    }]
})
```


## Example

```js
import ArgOverProp from '@stamp/arg-over-prop';

const HasColor = ArgOverProp.argOverProp('color', 'background');
const HasPoint = ArgOverProp.argOverProp({ x: 0, y: 0 });

const ColorPoint = compose(HasColor, HasPoint);

const point = ColorPoint({ color: 'blue', x: 15 });

console.log(point.color); // "blue"
console.log(point.background); // undefined
console.log(point.x); // 15
console.log(point.y); // 0
```
npm package: @stamp/check-compose
Description: Command line tool to test your 'compose' function implementation
Latest version: 1.0.3

# check-compose
Command line tool to test your ['compose' function implementation](https://github.com/stampit-org/stamp-specification)

## Install

```sh
$ npm i -g @stamp/check-compose
```

## Usage

### Command line

```sh
$ check-compose path/to/compose.js
```

### Programmatically

```js
import checkCompose from 'check-compose';
checkCompose(myComposeFunction).then(({failures}) => {
  console.error(failures.join('\n'));
});
```
npm package: @stamp/configure
Description: Access configuration of your stamps anywhere
Latest version: 1.0.2

# @stamp/configure

_Access configuration of your stamps anywhere_

Configuration is powerful feature of stamps as it allows you to store additional information with the stamp without interfering with properties or methods. Consider following example.

## Usage

```js
import compose from '@stamp/compose'
import jwt from 'jsonwebtoken'

const Jwt = compose({
  configuration: {
    jwtSecret: process.env.SECRET,
  },
  initializers: [
    initializeJwt(_, { stamp }) {
      const { jwtSecret } = stamp.compose.configuration
      ...
      this.createJwtToken = (payload) => jwt.sign(payload, jwtSecret)
      this.verifyJwtToken = (token) => jwt.verify(token, jwtSecret)
    }
  ]
})
```

That approach brings several advantages.

 * Clearly specify what makes the stamp tick.
 * Configured values are immutable.
 * Stamp with a modified configuration can be made.

The last bullet is especially useful for automated testing allowing you to insert different values based on various conditions. Unfortunately, there is apparent boilerplate hidden behind this, and it can get tedious for a larger project.

Now consider next example that is using `@stamp/configure` stamp.

```js
import Configure from '@stamp/configure'
import jwt from 'jsonwebtoken'

const Jwt = Configure.compose({
  configuration: {
    jwtSecret: process.env.SECRET,
  },
  methods: {
    createJwtToken(payload) {
      return jwt.sign(payload, this.config.jwtSecret)
    },
    verifyJwtToken(token) {
      return jwt.verify(token, this.config.jwtSecret)
    }
  }
})
```

Looks good, doesn't it? But wait, all those advantages of the configuration are suddenly gone, right? Not exactly.

Under the hood, we are using `@stamp/privatize` stamp. That allows us to access `this.config` within our methods and yet keep them hidden from outside world. Immutability is ensured by using `Object.freeze()`.

The `deepConfiguration` gets assigned to the same `this.config` object as well while the `configuration` has a precedence over it. In case of name conflict, the value from `configuration` always wins.

### No fan of @stamp/privatize ?

By including `@stamp/configure` your whole stamp is privatized by default which you may not like that much. For that case, we are offering opt-out option of using `Configure.noPrivatize()` instead of plain `Configure`.
npm package: @stamp/convert-class
Description: Converts ES6 class to stamp
Latest version: 1.0.3

# @stamp/convert-class

Converts an ES6 class to a stamp respecting the class's inheritance chain. The prototype chain is squashed into the `methods` of a stamp.

`npm i -S @stamp/convert-class`

# Example

```js
class CParent {
  constructor(arg1) {
    this.parentProp = arg1
  }

  commonMethod() { return 'parent' }
  parentMethod() { return 'parent' }

  static commonStaticMethod() { return 'parent' }
  static parentStaticMethod() { return 'parent' }
}

class CChild extends CParent {
  constructor(arg1, arg2) {
    super(arg1)
    this.childProp = arg2
  }

  commonMethod() { return super.commonMethod() } // overriding parent method 
  childMethod() { return 'child' }

  static commonStaticMethod() { return super.commonStaticMethod() } // overriding parent static method
  static childStaticMethod() { return 'child' }
}

const convertClass = require('@stamp/convert-class');

const Stamp = convertClass(CChild);

// parent class method
Stamp.compose.methods.parentMethod === CParent.prototype.parentMethod;
// child class method
Stamp.compose.methods.childMethod === CChild.prototype.childMethod;
// the overridden method
Stamp.compose.methods.commonMethod === CChild.prototype.commonMethod;
// The `super` inside regular method is delegated to parent
Stamp().commonMethod() === (new CChild()).commonMethod() === 'parent';

// parent static method
Stamp.parentStaticMethod === CParent.parentStaticMethod;
// child static method
Stamp.childStaticMethod === CChild.childStaticMethod;
// the overridden static method
Stamp.commonStaticMethod === CChild.commonStaticMethod;
// The `super` inside static methods of child classes is also delegated to parent 
Stamp.commonStaticMethod() === CChild.commonStaticMethod() === 'parent';
```
npm package: @stamp/core
Description: Core functions for creating stamps
Latest version: 1.0.1

# @stamp/core

_Core functions for creating stamps_

```js
const {assign, merge} = require('@stamp/core');
// or
import {assign, merge} from '@stamp/core';
```

### assign(dst, ...sources)
_`@stamp/core/assign`_

Mutates destination object with shallow assign of passed source objects. Returns destination object.

### merge(dst, ...sources)
_`@stamp/core/merge`_

* Mutates destination object by deeply merging passed source objects.
* Arrays are concatenated, not overwritten.
* Everything else but plain objects are copied by reference.

Returns destination object/array or a new object/array in case it was not.
npm package: @stamp/eventemittable
Description: Node.js' EventEmitter as a stamp
Latest version: 1.0.2

# @stamp/eventemittable

_Node.js' EventEmitter as a stamp_

```js
const EventEmittable = require('@stamp/eventemittable');
// or
import EventEmittable from '@stamp/eventemittable';
```

### Example

Create event emitter object:
```js
const emitter = EventEmittable();
```

Create a Stamp which implements Node.js' `EventEmitter` API via composition:
```js
import stampit from '@stamp/it';

const MyStamp = stampit({
  methods: {
   foo () {
     this.emit('foo', 'bar');
   }
  }
})
  .compose(EventEmittable);

const myObject = MyStamp();
myObject.on('foo', value => {
  console.log(`value: ${value}`);
});
myObject.foo(); // prints "value: bar"
```

### Notes

- For portability, this package consumes the userland `EventEmitter` implementation of the [events](https://npm.im/events) package.
- `domain`s are not supported.
npm package: @stamp/fp-constructor
Description: Adds the Functional Programming capabilities to your stamps
Latest version: 1.0.1

# @stamp/fp-constructor

* _Adds the `Stamp.of` static property referencing Stamp itself_
* _Adds the `instance.constructor` property referencing Stamp itself_

By composing the `@stamp/fp-constructor` into your stamp
```js
MyStamp = MyStamp.compose(FpConstructor);
```
you get the static method `.of`:
```js
MyStamp.of === MyStamp; // true
```

and the instance method, `.constructor`:
```js
instance = MyStamp(/* ...options */);
instance.constructor === MyStamp; // true
```

## Motivation

Frequently, it's desirable to instantiate a new instance of a given datatype inside a generic function. However, JavaScript lacks a built-in way to do that which is reliable. Classes throw errors if you leave off `new`, and arrow function factories will throw if you try to instantiate an instance with `new`, and there's no standard way to inject a value into the new datatype.

The `Stamp.of()` is a standard way to create a new value of a given stamp where the calling conventions are unambiguous: It does not require `new`, and you inject the value by passing the necessary arguments directly into the `.of()` static method.

Having the `.of()` method only solves half of the problem, though. You still need a way got get a handle on the stamp from an object instance. You can do that with the `instance.constructor()` method.

Here's an example of what you can do with the combination. The following `empty()` utility will return an empty instance of whatever supporting datatype you pass in, including standard JavaScript arrays:

```js
const empty = ({ constructor } = {}) => constructor.of ?
  constructor.of() :
  undefined
;

const foo = [23];

console.log(
  empty(foo) // []
);
```

All [applicative functors](https://github.com/fantasyland/fantasy-land#applicative) in JavaScript should implement `.of()`.

## Usage

```js
import FpConstructor from '@stamp/fp-constructor';

MyStamp = MyStamp.compose(FpConstructor);
```

## API

### Static methods

#### methods
`stamp.of(...args) => Object`

### Instance methods

### methods
`instance.constructor(...args) => Object`
npm package: @stamp/init-property
Description: Replaces properties which reference stamps with objects created from the stamps
Latest version: 1.0.1

# @stamp/init-property

_Replaces properties which reference stamps with objects created from the stamps_

If your StampA would have, say, property `foo` which references a StampB, then the property will be replaced with the StampB instance. The parameter for the `StampB(arg)` will be taken form the `foo` property of the StampA argument.

You might find it useful for better Dependency Injection pattern. 

## Usage

```js
const StampA = compose({
    properties: {
        foo: StampB
    }
})
.compose(InitProperty);

// StampB will receive initializer argument `{bar: 'baz'}`
StampA({foo: {bar: 'baz'}});
```


## Example

```js
import InitProperty from '@stamp/init-property';

import Oauth2 from './stamps/oauth2';

const GravatarClient = compose(InitProperty, {
  properties: {
    auth: Oauth2 // the 'auth' property is expected to be passed to the stamp
  },
  methods: {
    getProfilePicture() {
      return fetch('gravatar.com', {
        headers: {
          Authorization: this.auth.getHttpHeader() // accessing this.auth
        }
      });
    }
  }
});

const gravatarClient = GravatarClient({
  auth: { // Passing the data for the 'Oauth2' stamp
    client_id: '1', client_secret: '2', grant_type: 'simple'
  }
});
gravatarClient.getProfilePicture().then(stream => fs.writeFileSync(stream));
```
npm package: @stamp/instanceof
Description: Enables `obj instanceof MyStamp` in ES6 environments
Latest version: 1.0.1

# @stamp/instanceof

_Enables `obj instanceof MyStamp` in ES6 environments_

```js
const InstanceOf = require('@stamp/InstanceOf');
// or
import InstanceOf from '@stamp/InstanceOf';
```

### Example

Create a stamp:
```js
let MyStamp = compose({
  properties: { ... },
  initializers: [function () { ... }]
});
```

The following doesn't work:
```js
const obj = MyStamp();
obj instanceof MyStamp === false;
```

Compose the `InstanceOf` to your stamp:
```js
MyStamp = MyStamp.compose(InstanceOf);
```

Now it works:
```js
const myObject = MyStamp();
obj instanceof MyStamp === true;
```


### Notes

- We do not recommend to use `instanceof` in JavaScript in general.
npm package: @stamp/is
Description: Various checking functions used with stamps
Latest version: 1.0.0

# @stamp/is

_Various checking functions used with stamps_

```js
import {isStamp, isDescriptor, isComposable} from '@stamp/is';
// or
const {isStamp, isDescriptor, isComposable} = require('@stamp/is');
```

### isStamp(arg)
_`@stamp/is/stamp`_

Checks if passed argument is a function and has a `.compose()` property.

### isDescriptor(arg)
_`@stamp/is/descriptor`_

Checks if passed argument is considered a descriptor.

### isComposable(arg)
_`@stamp/is/composable`_

Checks if passed argument is considered as composable (aka stamp or descriptor).
npm package: @stamp/named
Description: (Re)Name a stamp factory function
Latest version: 1.0.2

# @stamp/named

_Changes the `Stamp.name` property using the [new ES6 feature](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name)._

[Supported platforms](http://kangax.github.io/compat-table/es6/#test-function_name_property_isn't_writable,_is_configurable): node>=4, iOS>=10, Edge, FF, Chrome, Safari

If used in a non-supported environment (node <v4, or IE any version) then nothing will throw. But the `Stamp.name` will always be `"Stamp"`.

# Example

Default behaviour (without this stamp):
```js
const MyRegularStamp = compose(...);
console.log(MyRegularStamp.name); // 'Stamp'
```

New behaviour:
```js
import Named from '@stamp/named';

const MyNamedStamp = MyRegularStamp.compose(Named).setName('MyNamedStamp');
```

Or if you don't want to import the stamp you can import only the method:
```js
import {setName} from '@stamp/named';
const MyNamedStamp = MyRegularStamp.compose(setName('MyNamedStamp'));
```

Then stamp receives a different name instead of the default "Stamp":
```js
console.log(MyNamedStamp.name); // 'MyNamedStamp'
```

Derived stamps behaviour:
```js
// All derived stamps will also be named 'MyNamedStamp' until changed:
let Stamp2 = compose(..., MyNamedStamp, ...);
console.log(Stamp2.name); // WARNING! Still 'MyNamedStamp' !!!

// Overwriting the name
Stamp2 = Stamp2.setName('Stamp2');
console.log(Stamp2.name); // 'Stamp2' :)
```
npm package: @stamp/required
Description: Insist on a method/property/staticProperty/configuration presence
Latest version: 1.0.1

# @stamp/required

_Insist on a method/property/staticProperty/configuration presence_

This stamp (aka behavior) will throw if a method (property, staticProperty, configuration, etc) is missing at object creation. 

## Usage

```js
import Required from '@stamp/required'

const InsistOnRedrawMethod = Required.required({methods: {redraw: Required}})
```

Or if you don't want to import the stamp you can import only the method:
```js
import {required} from '@stamp/required'
const InsistOnRedrawMethod = required({methods: {redraw: required}})
```

## API

### Static methods

#### required
Setup which things are required 
`stamp.required({METATYPE: {KEY: required}}) -> Stamp`


## Example

```js
import stampit from '@stamp/it'
import Required, {required} from '@stamp/required'

const requiredConfigurationDifficulty = required({configuration: {difficulty: required}})
const requiredMethodMove = required({methods: {move: Required}})
const requiredPropertyGuild = Required.required({properties: {guild: required}})

let Paladin = stampit({
  props: {
    mana: 50,
    strength: 50,
    health: 100
  }
})

const paladin = Paladin() // ok

Paladin = Paladin.compose(
  requiredConfigurationDifficulty, 
  requiredMethodMove, 
  requiredPropertyGuild
)

const paladin = Paladin() // THROWS - Required: There must be difficulty in this stamp configuration

Paladin = Paladin.conf({ difficulty: 5 })

const paladin = Paladin() // THROWS - Required: There must be move in this stamp methods

Paladin = Paladin.methods({
  move(x, y) {
    // ... implementation
  }
})

const paladin = Paladin() // THROWS - Required: There must be guild in this stamp properties

Paladin = Paladin.props({ guild: 'Warriors of Light' })

const paladin = Paladin() // ok
```
npm package: @stamp/shortcut
Description: Adds handy shortcuts for stamp composition
Latest version: 1.0.2

# @stamp/shortcut

_Adds few handy static methods for simpler composition_

By composing the `@stamp/shortcut` into your stamp
```js
MyStamp = MyStamp.compose(Shortcut);
```
you get few static methods. So, instead of typing
```js
MyStamp.compose({ deepProperties: bla });
```
you will be able to write
```js
MyStamp.deepProps(bla);

```

## Usage

```js
import Shortcut from '@stamp/shortcut';

const MyStamp = Shortcut
  .methods({ myMethod() {} })
  .props({ foo: 'foo' })
  .deepProps({ deepFoo: { foo: 'foo 2' } })
  .statics({ bar: 'bar' })
  .deepStatics({ deepBar: { bar: 'bar 2' } })
  .conf({ something: 'something' })
  .deepConf({ deepSomething: { something: 'something' } })
  .init((arg, {stamp, args, instance}) => { /* initializer */ })
  .composers(({stamp, composables}) => { /* composer */ });
```

Or you can import each individual shortcut function:
```js
import {
  methods, props, deepProps, statics, deepStatics, conf, deepConf, init, composers
} from '@stamp/shortcut';

const Stamp1 = methods({
  method1() { }
});
const Stamp2 = props({
  prop2: 2
});
const Stamp3 = init(function () {
  console.log(3);
});
// etc
```

In this case the functions will not add any static shortcut methods to your stamps, meaning that the following will throw:
```js
methods({ method1() {} }).props(); // Error: undefined "props" is not a function
init(function () {}).init(); // Error: undefined "init" is not a function
// etc
```


## API

### Static methods

#### methods
`stamp.methods(Object) -> Stamp`

#### props
`stamp.props(Object) -> Stamp`

#### deepProps
`stamp.deepProps(Object) -> Stamp`

#### statics
`stamp.statics(Object) -> Stamp`

#### deepStatics
`stamp.deepStatics(Object) -> Stamp`

#### conf
`stamp.conf(Object) -> Stamp`

#### deepConf
`stamp.deepConf(Object) -> Stamp`

#### init
`stamp.init(...Function) -> Stamp`

#### composers
`stamp.composers(...Function) -> Stamp`
npm package: @stampinup/vue-components
Description: Stampinup vue components
Latest version: 1.22.26

<p align="center"><img align="center" src="https://media.stampinup.com/core/images/logo_customer.png"/></p><br/>

[![Build Status](https://dev.azure.com/stampinup/Ordering%20System/_apis/build/status/Vue%20Components/Gate%20-%20Vue%20Components?branchName=master)](https://dev.azure.com/stampinup/Ordering%20System/_build/latest?definitionId=415&branchName=master)

# Stampin' Up! Vue-Components

## Getting Started

### Prerequisites

 - [Node](https://github.com/nvm-sh/nvm)
 - [Yarn](https://yarnpkg.com/en/docs/install#windows-stable)


### Running
```sh
$ npm i -g yarn 
```
```sh
$ yarn install
```
npm package: @stampmyvisa/react-flagpack
Description: Gorgeous flag components for your React project.
Author: Yummygum
Latest version: 1.2.0

# Flagpack

Flagpack contains 250+ flag icons to easily use within your code project. Flagpack is an open source project and available for JavaScript frameworks/libraries React, Vue and Svelte.

![Flagpack. 260+ easily implementable flag icons to use in your design or code project. Open Source. Available for Sketch, Figma, Angular, Vue, and React. [www.flagpack.xyz](https://www.flagpack.xyz). Made with love by Yummygum. Graphic showing a list with the flags of Argentina, Croatia, Estonia, Kenia, Netherlands, and Scotland.](https://flagpack.xyz/meta-image.png)

[View documentation on flagpack.xyz](https://flagpack.xyz/docs/)

## react-flagpack
<p>
  <a href="https://www.npmjs.com/package/react-flagpack" target="_blank">
    <img src="https://img.shields.io/npm/v/react-flagpack.svg?style=flat" />
  </a>
  <a href="https://www.npmjs.com/package/react-flagpack" target="_blank">
    <img src="https://img.shields.io/npm/dt/react-flagpack.svg?style=flat" />
  </a>
  <a href="https://github.com/sponsors/Yummygum" target="_blank">
    <img src="https://img.shields.io/badge/Support-♥-E94AAA"  />
  </a>
  <a href="https://twitter.com/flagpack" target="_blank">
    <img src="https://img.shields.io/twitter/follow/flagpack.svg?style=social&label=follow"  />
  </a>
</p>

Flagpack for React is created using React v16.8. The Flagpack component has not been tested for compatibility with older versions of React.

## Installation

```bash
$: npm install react-flagpack --save
```

## Usage

### Defining the component
Import the Flagpack component into any of your project's React components.
```js
import Flag from 'react-flagpack'
```

### Use in JSX
```jsx
<Flag
  code="NL"
  gradient="real-linear"
  size="m"
  hasDropShadow
/>
```

## Available component configurations — Props

| Key   | Value   | Required | Default | Format |
|-------|-------|------|------|------|
| code |  String | false | 'NL' | [See all codes](https://flagpack.xyz/docs/flag-index/) |
| size |  String | false | 'L' | 'S', 'M' or 'L' |
| className |  String | false | - | - |
| hasDropShadow |  Boolean | false | false | - |
| hasBorder |  Boolean | false | true | - |
| hasBorderRadius | Boolean | false | true | - |
| gradient |  String | false | '' | 'top-down', 'real-linear' or 'real-circular' |

## Support

[Frequently Asked Questions](https://flagpack.xyz/support/)

[Documentation](https://flagpack.xyz/docs/)

## Releases

You can find a changelog of Flagpack's releases on the [Releases page](https://github.com/Yummygum/react-flagpack/releases) on GitHub.

## Contribute

If you're interested in contributing to this project, great! Please see the [contributing document](CONTRIBUTING.md) how to set up you up.

## License

Flagpack is an open source project published under a [MIT license](LICENSE).
npm package: @stan-chen/typellm
Description: Strictly typed, agent-first LLM bridge for TypeScript.
Author: Antigravity
Latest version: 0.1.2
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# TypeLLM

A strictly typed bridge for LLM tool-calling. Designed to normalize inconsistent model outputs into predictable TypeScript objects.

## The Problem
Most LLM providers are optimized for conversation, not state-machine execution. Models often hallucinate key names (e.g., using `command` instead of `tool`) or wrap JSON in conversational filler that breaks standard parsers.

## The Solution
TypeLLM acts as a resilient middleware layer that:
1.  **Normalizes Keys**: Maps common variations like `action`, `operation`, and `parameters` into a standard `tool` and `args` schema.
2.  **Repairs JSON**: Automatically extracts JSON from rambling text and fixes trailing commas or unclosed braces.
3.  **Enforces Types**: Provides a consistent TypeScript interface across OpenAI, Anthropic, and Gemini.

## Installation

```bash
npm install @stancsz/typellm
```

## Quick Start

```typescript
import { createTypeLLM } from '@stancsz/typellm';

const agent = createTypeLLM({
  provider: 'openai',
  model: 'gpt-4o-mini'
});

const res = await agent.generate(
  "Filesystem Assistant",
  [{ role: 'user', content: 'Rename index.js to main.js' }]
);

// Unified output irrespective of model rambling
console.log(res.tool); // "move"
console.log(res.args); // { from: "index.js", to: "main.js" }
```

## Core Features
*   **Hallucination Mapping**: Intelligent fallback for key name variations.
*   **Deep Repair**: Integrated `jsonrepair` and regex-based extraction.
*   **Provider Agnostic**: Unified wrapper for major AI SDKs.
*   **Zero Dependency Core**: Lightweight and suitable for Edge and CLI runtimes.

## Development

```bash
git clone https://github.com/stancsz/TypeLLM.git
npm install
npm run build
```

LICENSE: MIT
npm package: @stan-custom-yiitap/core
Description: Yiitap core functions
Author: Yiitap
Latest version: 0.17.3

# @yiitap/core
[![Version](https://img.shields.io/npm/v/@yiitap/core.svg?label=version)](https://www.npmjs.com/package/@yiitap/core)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/core.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/core.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-ai-block
Description: AI block extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-ai-block
[![Version](https://img.shields.io/npm/v/@yiitap/extension-ai-block.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-ai-block)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-ai-block.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-ai-block.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-blockquote
Description: blockquote extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-blockquote
[![Version](https://img.shields.io/npm/v/@yiitap/extension-blockquote.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-blockquote)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-blockquote.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-blockquote.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-callout
Description: Link extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-callout
[![Version](https://img.shields.io/npm/v/@yiitap/extension-callout.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-callout)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-callout.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-callout.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-char-command
Description: Slash extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-char-command
[![Version](https://img.shields.io/npm/v/@yiitap/extension-char-command.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-char-command)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-char-command.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-char-command.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-code-block
Description: Code block extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-code-block
[![Version](https://img.shields.io/npm/v/@yiitap/extension-code-block.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-code-block)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-code-block.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-code-block.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-color-highlighter
Description: Color highlighter extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-color-highlighter
[![Version](https://img.shields.io/npm/v/@yiitap/extension-color-highlighter.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-color-highlighter)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-color-highlighter.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-color-highlighter.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-image
Description: Image extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-image
[![Version](https://img.shields.io/npm/v/@yiitap/extension-image.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-image)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-image.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-image.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-inline-placeholder
Description: Inline placeholder extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-inline-placeholder
[![Version](https://img.shields.io/npm/v/@yiitap/extension-inline-placeholder.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-inline-placeholder)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-inline-placeholder.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-inline-placeholder.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-link
Description: Link extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-link
[![Version](https://img.shields.io/npm/v/@yiitap/extension-link.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-link)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-link.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-link.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-model-viewer
Description: 3D model viewer extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-model-viewer
[![Version](https://img.shields.io/npm/v/@yiitap/extension-model-viewer.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-model-viewer)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-model-viewer.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-model-viewer.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).
npm package: @stan-custom-yiitap/extension-multi-column
Description: Multi-column extension
Author: Yiitap
Latest version: 0.17.3

# @yiitap/extension-multi-column
[![Version](https://img.shields.io/npm/v/@yiitap/extension-multi-column.svg?label=version)](https://www.npmjs.com/package/@yiitap/extension-multi-column)
[![Downloads](https://img.shields.io/npm/dm/@yiitap/extension-multi-column.svg)](https://npmcharts.com/compare/yiitap?minimal=true)
[![License](https://img.shields.io/npm/l/@yiitap/extension-multi-column.svg)](https://github.com/pileax-ai/yiitap/blob/main/LICENSE)

## Introduction
Yiitap is a WYSIWYG rich-text block-based editor built on top of [tiptap](https://tiptap.dev).

## Official Documentation
Documentation can be found on the [Yiitap website](https://yiitap.pileax.ai).


## Acknowledgements

@yiitap/extension-multi-column is built on top of [prosemirror-columns](https://github.com/GYHHAHA/prosemirror-columns). Thanks to [Yuanhao Geng](https://github.com/GYHHAHA).

## License
Yiitap is open sourced software licensed under the [MIT license](https://github.com/pileax-ai/yiitap/blob/main/LICENSE).