open-index/open-npm huggingface dataset:
npm package: @madisonreed/amazon-payments
Description: API wrapper for Amazon Payments
Author: Scott Stokes
Latest version: 0.2.5

## Installation:

``` sh
npm install amazon-payments
```

## Usage:

Initialize the amazonPayment object with the environment variable, and all required config parameters.

The `amazonPayments.Environment` object contains two properties: `Production` and `Sandbox`, pass one of these in the configuration object.

__Example:__

``` js
var amazonPayments = require('amazon-payments');
var payment = amazonPayments.connect({
  environment: amazonPayments.Environment.Production,
  sellerId: 'Amazon Seller ID',
  mwsAccessKey: 'MWS Access Key',
  mwsSecretKey: 'MWS Secret Key',
  clientId: 'Client ID'
});
```

## Note about request parameters

This module will automatically sign all requests and convert nested objects to dot notation.

__Example:__
``` js
payment.offAmazonPayments.refund({
  AmazonCaptureId: 'Amazon capture ID',
  RefundReferenceId: 'Refund Reference ID',
  RefundAmount: {
    Amount: 123.45,
    CurrencyCode: 'USD'
  }
}, function(err) {
  console.log(err);
})
```
Will make a call with the following parameters:
``` json
{
  "AmazonCaptureId": "Amazon capture ID",
  "RefundReferenceId": "Refund Reference ID",
  "RefundAmount.Amount": 123.45,
  "RefundAmount.CurrencyCode": "USD"
}
```

## api.getTokenInfo(accessToken, callback)

getTokenInfo takes two parameters: accesToken and callback. [More Info](http://docs.developer.amazonservices.com/en_US/apa_guide/APAGuide_ObtainProfile.html)

callback: err, tokenInfo

__Example:__

``` js
payment.api.getTokenInfo('access token from button', function(err, tokenInfo) {
  console.log(tokenInfo);
});
```

## api.getProfile(accessToken, callback)

getProfile takes two parameters: accesToken and callback. [More Info](http://docs.developer.amazonservices.com/en_US/apa_guide/APAGuide_ObtainProfile.html)

callback: err, profile

__Example:__

``` js
payment.api.getProfile('access token from button', function(err, profile) {
  console.log(profile);
});
```


## offAmazonPayments.*

All the methods in the offAmazonPayments object take two parameters: params and callback. 
The functions are all named the same as their respective API calls, except with a lowercase first letter.
[More Info](http://docs.developer.amazonservices.com/en_US/off_amazon_payments/OffAmazonPayments_Overview.html)
npm package: @madisonreed/gulp-raygun-sourcemaps
Description: Uploads sourcemaps from gulp into Raygun
Author: raygun
Latest version: 1.0.1

# gulp-raygun-sourcemaps

Uploads source maps and source files from gulp to Raygun.

#### To install

	npm install gulp-raygun-sourcemaps --save-dev

#### Using

	.pipe(raygunUpload.upload({
	   app: '' // Your app id,
	   key: '' // Your external access token (https://app.raygun.io/user),
	   root: __dirname // This probably doesn't need changing,
	   minified: 'dist' // The directory that has your minified JS and .map files in it,
	   src: 'src/' // Where your unminified source lives,
	   url: 'http://localhost:8000/' // The URL of your site
	}))


#### Complete gulpfile.js sample

	var gulp = require('gulp');
	
	var uglify = require('gulp-uglify');
	var sourcemaps = require('gulp-sourcemaps');
	var raygunUpload = require('gulp-raygun-sourcemaps');
	
	gulp.task('default', function() {
		gulp.src('src/*.js')
			.pipe(sourcemaps.init())
			.pipe(uglify())
			.pipe(sourcemaps.write('.', {
				sourceRoot: '/src/'
			}))
			.pipe(gulp.dest('dist'))
			.pipe(raygunUpload.upload({
				app: '123456',
				key: '12345678912345678923456789',
				root: __dirname,
				minified: 'dist',
				src: 'src/',
				url: 'http://localhost:8000/'
			}));
	});
npm package: @madissia/json-reader
Description: A simple JSON reader and writer
Author: madissia
Latest version: 1.0.3

# JSONReader
A simple JSON reader and writer

## Usage
```javascript
// test.json
/*
{
	"timesRead": 0
}
*/
const JSONReader = require('@madissia/json-reader')

// Read JSON file
let json = JSONReader('test.json')

// Access data
if(!json.timesRead) // if data doesn't exist, create it
	json.timesRead = 0
console.log('"test.json" has been read ' + json.timesRead + ' times')

// Change data, doesn't affect file
json.timesRead += 1

// Write changes to file
json.save()
```

## License
Released under the [MIT License](./LICENSE)
npm package: @madkarma/fontshub-cli
Description: TypeScript CLI-only client for FontsHub
Latest version: 1.2.0

<h1 align="center">
    <picture>
        <source media="(prefers-color-scheme: dark)" srcset="https://fontshub.pro/images/logo_white.svg">
        <img src="https://fontshub.pro/images/logo_dark.svg">
    </picture>
    <p>@madkarma/fontshub-cli</p>
</h1>
<p align="center">
    <i>TypeScript CLI-only client for FontsHub</i>
</p>

## 🚀 Usage

```sh
bunx @madkarma/fontshub-cli
```

or

```sh
bun i -g @madkarma/fontshub-cli
fontshub
```

The same commands apply to all the other package managers.

> [!NOTE]  
> The fonts will be downloaded in the current directory.
npm package: @madkings/pictahub
Description: Display for Pictawall.
Author: Guylian Cox
Latest version: 2.7.6

# Pictawall - Social Hub Widget

## Usage

The built version of the SocialHub is available on the NPM registry, you can install it using

`npm install --save pictawall.socialhub`

The include it using a script tag.

`<script src="node_modules/pictawall.socialhub/dist/prod/pictahub.min.js">`

That script will expose a function called `pictawall.SocialHub` on the global object. Invoking it wil instanciate a new Social Hub.

Usage examples are available under `node_modules/pictawall.socialhub/examples`

*Note: It is fundamental that you do not modify the internal structure of the `dist/prod` folder and do not rename the 
main script as it is used to determine where the additionnal dependencies we need are located.*

## Supported Browsers

* Safari 6.2  
* Chrome 26  
* Firefox 25  
* Opera 25  
* IE 11

## Configuration

Setting up a SocialHub is straightforward, you simply need to pass your hub configuration to the function.

```javascript
pictawall.SocialHub({
    container: '#pictawall',
    eventIdentifier: 'social-media-night-stuttgart-1',
});
```

Configuration options are currently undocumented.

### Script Hash Configuration

The Social Hub also supports putting the configuration directly in the script url, as the hash, or in a `data-pictahub` attribute on the containing div. 
It must be in a json format and encoded in base64.

```html
<!-- Decodes to {"container":"#pictawall","eventIdentifier":"magritte"} -->
<script src="node_modules/pictawall.socialhub/dist/prod/pictahub.min.js#eyJjb250YWluZXIiOiIjcGljdGF3YWxsIiwiZXZlbnRJZGVudGlmaWVyIjoibWFncml0dGUifQ=="></script>

<!-- 
  Decodes to {"channelId":"24dee060-bd86-488e-acaa-659ac2e842e3"}. The div will be used as the container.
  The JavaScript file needs to be loaded after the div has been created for this version to work. 
  Either use the defer attribute or put the script at the bottom of the page.
-->
<div data-pictahub="eyJjaGFubmVsSWQiOiIyNGRlZTA2MC1iZDg2LTQ4OGUtYWNhYS02NTlhYzJlODQyZTMifQ=="></div>
```
npm package: @madkudu-core-tools/split
Description: CLI tool to split OpenAPI specifications by tags or routes
Author: MadKudu
Latest version: 1.2.0

# @madkudu-core-tools/split

A CLI tool to split OpenAPI specifications by tags or routes, extracting only the relevant paths and their referenced schemas.

## Installation

```bash
npm install -g @madkudu-core-tools/split
```

## Usage

### Split by Tag

Extract all routes under a specific tag and their referenced schemas:

```bash
# Local files
mct-split openapi.yaml -t user-management
mct-split openapi.json -t orders

# Remote URLs
mct-split --remote https://api.example.com/openapi.json -t user-management
mct-split --remote https://raw.githubusercontent.com/user/repo/main/openapi.yaml -t orders

# Save to file
mct-split openapi.yaml -t user-management -o users-api.json
mct-split --remote https://api.example.com/openapi.json -t users -o users-api.json
```

### Split by Route

Extract a specific route and its referenced schemas:

```bash
# Local files
mct-split openapi.yaml -r /users/{id}
mct-split openapi.json -r /orders

# Remote URLs
mct-split --remote https://api.example.com/openapi.json -r /users/{id}
mct-split --remote https://petstore.swagger.io/v2/swagger.json -r /pet/{petId}

# Save to file
mct-split openapi.yaml -r /users/{id} -o user-detail-api.json
mct-split --remote https://api.example.com/openapi.json -r /orders -o orders-api.json
```

### Options

- `-t, --tag <tag>`: Split by tag name
- `-r, --route <route>`: Split by route name
- `-o, --output <path>`: Output file path (if not specified, outputs to stdout)
- `--remote <url>`: Remote URL to fetch OpenAPI specification from
- `-h, --help`: Display help for command

## Features

- ✅ Supports both YAML and JSON OpenAPI specifications
- ✅ Extracts routes by tag or specific route path
- ✅ Automatically includes all referenced schemas, responses, parameters, etc.
- ✅ Preserves OpenAPI structure and metadata
- ✅ Output to stdout or save to file
- ✅ Remote URL support for fetching specs from web
- ✅ TypeScript support
- ✅ Comprehensive test coverage

## API

You can also use this package programmatically:

```typescript
import { splitByTag, splitByRoute } from "@madkudu-core-tools/split";

// Split by tag
const userRoutes = await splitByTag("openapi.yaml", "users");

// Split by route
const specificRoute = await splitByRoute("openapi.yaml", "/users/{id}");
```

## Development

```bash
# Install dependencies
pnpm install

# Build the project
pnpm run build

# Run tests
pnpm test

# Run tests in watch mode
pnpm run test:watch

# Lint code
pnpm run lint
```

## License

MIT
npm package: @madlad3718/mcvec3
Description: A library of advanced matrix and vector operations for use within the Minecraft scripting API.
Author: MADLAD3718
Latest version: 0.2.5
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

# MCVec3
A library of advanced matrix and vector operations for use within Minecraft Bedrock's scripting API. Most operations from the HLSL intrisics are implemented as well as some additional functions that are highly versatile, including conversions between the API's various interfaces.

## Namespaces:
1. **`Vec2`:** Includes operations on the `Vector2` interface for creation, manipulation and usage.
2. **`Vec3`:** Includes operations on the `Vector3` interface for creation, manipulation and usage.
3. **`Mat2`:** Includes various 2x2 matrix operations through the `Matrix2` interface. Enables construction, multiplication, inversion and more.
4. **`Mat3`:** Includes various 3x3 matrix operations through the `Matrix3` interface. Enables construction, multiplication, inversion and more.
5. **`RandVec`:** Includes utilities for generating random vectors from various uniform distributions.

## Examples:
Get the angle between the closest entity and the player's view direction:
```ts
import { Player } from "@minecraft/server";
import { Vec3 } from "@madlad3718/mcvec3";

function angleToClosestEntity(player: Player): number {
    // Get the closest entity to the player.
    const entity = player.dimension.getEntities({
        location: player.location,
        closest: 1
    })[0];

    // Get the difference vector pointing from the player's location
    // to the entity's location.
    const to_entity = Vec3.sub(entity.location, player.location);

    // Compute the dot product between the player's view vector and
    // the normalized player-entity difference vector.
    const view = player.getViewDirection();
    const v_dot_e = Vec3.dot(view, Vec3.normalize(to_entity));

    // Return the arccosine of the dot product. The dot product of two 
    // vectors A and B returns |A||B|cosθ, where θ is the angle between.
    return Math.acos(v_dot_e);
}
```

Get a random block within a 30° offset from a player's view direction:
```ts
import { Mat3, RandVec } from "@madlad3718/mcvec3";
import { Player, Block } from "@minecraft/server";

function randomVisibleBlock(player: Player): Block | undefined {
    // Get the player's head position and view vector.
    const origin = player.getHeadLocation();
    const view = player.getViewDirection();

    // Build a tangent-normal-binormal matrix around the view vector.
    // This represents a basis for the player's view space.
    const basis = Mat3.buildTNB(view);

    // Compute the direction by multiplying a random spherical cap
    // sample with maximum offset of 30° by the view matrix.
    const direction = Mat3.mul(basis, RandVec.cap(Math.PI / 6));

    // Get the block by casting a ray from the player's head position
    // in the computed direction.
    return player.dimension.getBlockFromRay(origin, direction);
}
```
npm package: @madlad3718/mcveclib
Description: A library of advanced matrix and vector operations for use within the Minecraft scripting API.
Author: MADLAD3718
Latest version: 0.3.2

# MCVecLib
A library of advanced matrix and vector operations for use within Minecraft Bedrock's scripting API. Most operations from the HLSL intrisics are implemented as well as some additional functions that are highly versatile, including conversions between the API's various interfaces.

## Namespaces:
1. **`Vec2`:** Includes operations on the `Vector2` interface for creation, manipulation and usage.
2. **`Vec3`:** Includes operations on the `Vector3` interface for creation, manipulation and usage.
3. **`Mat2`:** Includes various 2x2 matrix operations through the `Matrix2` interface. Enables construction, multiplication, inversion and more.
4. **`Mat3`:** Includes various 3x3 matrix operations through the `Matrix3` interface. Enables construction, multiplication, inversion and more.
5. **`RandVec`:** Includes utilities for generating random vectors from various uniform distributions.

## Examples:
Get the angle between the closest entity and the player's view direction:
```ts
import { Vec3 } from "@madlad3718/mcveclib";
import { Player } from "@minecraft/server";

function angleToClosestEntity(player: Player): number {
    // Get the closest entity to the player.
    const entity = player.dimension.getEntities({
        location: player.location,
        closest: 1
    })[0];

    // Get the difference vector pointing from the player's location
    // to the entity's location.
    const to_entity = Vec3.sub(entity.location, player.location);

    // Compute the dot product between the player's view vector and
    // the normalized player-entity difference vector.
    const view = player.getViewDirection();
    const v_dot_e = Vec3.dot(view, Vec3.normalize(to_entity));

    // Return the arccosine of the dot product. The dot product of two 
    // vectors A and B returns |A||B|cosθ, where θ is the angle between.
    return Math.acos(v_dot_e);
}
```

Get a random block within a 30° offset from a player's view direction:
```ts
import { Mat3, RandVec } from "@madlad3718/mcveclib";
import { Player, Block } from "@minecraft/server";

function randomVisibleBlock(player: Player): Block | undefined {
    // Get the player's head position and view vector.
    const origin = player.getHeadLocation();
    const view = player.getViewDirection();

    // Build a tangent-normal-binormal matrix around the view vector.
    // This represents a basis for the player's view space.
    const basis = Mat3.buildTNB(view);

    // Compute the direction by multiplying a random spherical cap
    // sample with maximum offset of 30° by the view matrix.
    const direction = Mat3.mul(basis, RandVec.cap(Math.PI / 6));

    // Get the block by casting a ray from the player's head position
    // in the computed direction.
    return player.dimension.getBlockFromRay(origin, direction);
}
```
npm package: @madlan145/emotion-monkey
Description: Manage emotion instances with React contexts mechanism.
Author: m1kak
Latest version: 0.3.2

# emotion-monkey 🐒 → 🦍

Manage [emotion](https://emotion.sh) instances with React context mechanism.

You probably don't need to use this. Please refer to [create-emotion](https://github.com/emotion-js/emotion/tree/master/packages/create-emotion) for use-cases.

## Motivation

Using single `emotion` instance works almost everytime. However when you need to have multiple instances of emotion, you may face issues with storing and managing them.

Monkeys will come to the rescue! 🙉

## Installation

```bash
npm i @madlan145/emotion-monkey -S
```

## Usage

In you app's entry point:

```typescript
import { EmotionProvider } from '@madlan145/emotion-monkey';
import createEmotion from 'create-emotion';

const emotion = createEmotion({});


const App: React.SFC<{}> = () => (
  <EmotionProvider emotion={emotion}>
    <Component label="Label 🐒" />
  </EmotionProvider>
);

```

Having EmotionProvider, you can use `styled` as you would normally use it with `react-emotion`.


To use css & other stuff from `emotion`:

```typescript
import { Emotion } from 'create-emotion';
import { injectEmotion } from '@madlan145/emotion-monkey';


const stylesheet = ({ css }: Emotion) => ({
  redButton: css`
    color: red;
  `,
  container: css`
    padding: 15px;
  `,
});


interface ComponentProps {
  styles: ReturnType<typeof stylesheet>;
  label: string;
}

const Component: React.SFC<ComponentProps> = ({ styles, label }) => (
  <div className={styles.container}>
    <button className={styles.redButton}>{label}</button>
  </div>
);

export default injectEmotion(stylesheet)(Component);

```