open-index/open-npm huggingface dataset:
npm package: @stbear/grunt-sass
Description: Compile Sass to CSS using sass
Author: stbear
Latest version: 3.1.0-stbear.1

# @w8tcha/grunt-sass

[<img src="https://github.com/sass/sass-site/blob/main/source/assets/img/logos/logo-seal.png" width="150" align="right">](https://sass-lang.com)

> Compile Sass to CSS using [Dart Sass][].

[Dart Sass]: http://sass-lang.com/dart-sass

Before filing an issue with this repository, please consider:

* Asking support questions on Use [Stack Overflow][].

* Reporting issues with the output on the [Dart Sass][Dart Sass issues] issue trackers, depending which implementation you're using.

* Reporting installation issues on the [Dart Sass][Dart Sass issues] issue trackers, depending on which implementation you're using.

[Stack Overflow]: https://stackoverflow.com/questions/tagged/node-sass
[Dart Sass issues]: https://github.com/sass/dart-sass/issues/new


## Install

```
$ npm install --save-dev @w8tcha/grunt-sass
```


## Usage

```js
const sass = require('sass');

require('load-grunt-tasks')(grunt);

grunt.initConfig({
	sass: {
		options: {
			implementation: sass,
			sourceMap: true
		},
		dist: {
			files: {
				'main.css': 'main.scss'
			}
		}
	}
});

grunt.registerTask('default', ['sass']);
```

You can choose whether to use [Dart Sass][] or [Node Sass][] by passing the module to the `implementation` option. One implementation or the other *must* be passed.

Note that when using Dart Sass, **synchronous compilation is twice as fast as asynchronous compilation** by default, due to the overhead of asynchronous callbacks. To avoid this overhead, you can use the [`fibers`](https://www.npmjs.com/package/fibers) package to call asynchronous importers from the synchronous code path. To enable this, pass the `Fiber` class to the `fiber` option:

```js
const Fiber = require('fibers');
const sass = require('sass');

require('load-grunt-tasks')(grunt);

grunt.initConfig({
	sass: {
		options: {
			implementation: sass,
			fiber: Fiber,
			sourceMap: true
		},
		dist: {
			files: {
				'main.css': 'main.scss'
			}
		}
	}
});

grunt.registerTask('default', ['sass']);
```

Files starting with `_` are ignored to match the expected [Sass partial behaviour](http://sass-lang.com/documentation/file.SASS_REFERENCE.html#partials).


## Options

See the Node Sass [options](https://github.com/sass/node-sass#options), except for `file`, `outFile`, `success`, `error`.

The default value for the `precision` option is `10`, so you don't have to change it when using Bootstrap.
npm package: @stblassitude/mumble-client-codecs-browser
Description: Mumble protocol client library - pure js codecs
Author: Jonas Herzig
Latest version: 1.2.1

# mumble-client-codecs-browsers

This module provides the [Opus codec] and the [CELT Alpha codec] for the [mumble-client] module for use in the browser via [browserify].
Neither CELT Beta nor Speex are supported at this time.
When native libraries are acceptable and more performance is required, consider using [mumble-client-codecs-node] instead.

[WebWorker]s are used for en/decoding.

### Usage

```javascript
var BrowserCodecs = require('mumble-client-codecs-browsers')

var client = new MumbleClient({
  username: 'Test',
  codecs: BrowserCodecs
})
```

### License
MIT

[Opus codec]: https://github.com/johni0702/libopus.js
[CELT Alpha codec]: https://github.com/johni0702/libcelt7.js
[browserify]: http://browserify.org/
[mumble-client]: https://github.com/johni0702/mumble-client
[mumble-client-codecs-node]: https://github.com/johni0702/mumble-client-codecs-node
[WebWorker]: https://github.com/substack/webworkify
npm package: @stble/react
Description: React components for Crypto Checkout - Drop-in buttons and embeds
Latest version: 1.2.1

# @stble/react

React components for stble checkout - Premium, drop-in payment buttons and embeds.

## Installation

```bash
npm install @stble/react @stble/sdk
# or
yarn add @stble/react @stble/sdk
# or
pnpm add @stble/react @stble/sdk
```

## Quick Start

```tsx
import { CheckoutProvider, StblePayButton } from '@stble/react';

function App() {
  return (
    <CheckoutProvider apiKey="ck_test_xxx">
      <ProductPage />
    </CheckoutProvider>
  );
}

function ProductPage() {
  return (
    <div>
      <h1>Premium Product - $10</h1>
      <StblePayButton
        mode="payment"
        amount={10_000000}
        currency="USD"
        chain="base"
        successUrl="https://yoursite.com/success"
        cancelUrl="https://yoursite.com/cancel"
      />
    </div>
  );
}
```

## Components

### CheckoutProvider

Wrap your app with the provider to enable checkout functionality.

```tsx
<CheckoutProvider 
  apiKey="ck_test_xxx"
  baseUrl="https://api.stble.cc" // optional
>
  {children}
</CheckoutProvider>
```

### StblePayButton

A premium, animated, and borderless button that handles the entire payment flow. It features:
- **Chain cycling animation**: Smoothly cycles through supported networks (Solana, Base, Polygon).
- **Vibrant aesthetics**: Interactive glow effects matching the active chain.
- **Official branding**: Integrated stble logo.

```tsx
<StblePayButton
  mode="payment"
  amount={10_000000}       // $10 USD in micro-units
  currency="USD"           // or "USDC", "EUR", etc.
  chain="base"             // primary chain for checkout
  successUrl="/success"
  cancelUrl="/cancel"
  metadata={{ orderId: '123' }}
  
  // Optional styling overrides
  className="my-custom-class"
  style={{ maxWidth: '400px' }}
  
  // Callbacks
  onError={(error) => console.error(error)}
/>
```

### CheckoutEmbed

Embed the checkout directly in your page.

```tsx
<CheckoutEmbed
  sessionId="cs_xxx"
  width="100%"
  height={600}
  onComplete={(data) => {
    console.log('Payment complete:', data.paymentId);
  }}
  onCancel={() => {
    console.log('Payment cancelled');
  }}
  onError={(error) => {
    console.error('Checkout error:', error);
  }}
/>
```

## Hooks

### useCheckout

Access checkout functionality anywhere in your app.

```tsx
function CustomCheckout() {
  const { createSession, redirectToCheckout, isLoading, error } = useCheckout();

  const handleCustomFlow = async () => {
    const session = await createSession({
      mode: 'payment',
      amount: 10_000000,
      chain: 'base',
      successUrl: '/success',
      cancelUrl: '/cancel',
    });
    
    // Redirect when ready
    window.location.href = session.checkoutUrl;
  };

  return (
    <button onClick={handleCustomFlow} disabled={isLoading}>
      {isLoading ? 'Loading...' : 'Checkout Now'}
    </button>
  );
}
```

## License

MIT
npm package: @stble/sdk
Description: Official SDK for Crypto Checkout - Accept crypto payments in your app
Latest version: 1.0.4

# @stble/sdk

Official Node.js/TypeScript SDK for Crypto Checkout - Accept crypto payments in your app.

## Installation

```bash
npm install @stble/sdk
# or
yarn add @stble/sdk
# or
pnpm add @stble/sdk
```

## Quick Start

```typescript
import Checkout from '@stble/sdk';

const checkout = new Checkout('ck_test_xxx');

// Create a checkout session
const session = await checkout.sessions.create({
  mode: 'payment',
  amount: 10_000000, // $10 USD (in micro-units)
  currency: 'USD',
  chain: 'base',
  success_url: 'https://yoursite.com/success',
  cancel_url: 'https://yoursite.com/cancel',
});

// Redirect to hosted checkout
res.redirect(session.checkout_url);
```

## API Reference

### Sessions

```typescript
// Create a session
const session = await checkout.sessions.create({
  mode: 'payment',
  amount: 10_000000,
  currency: 'USD', // or 'USDC', 'EUR', 'GBP'
  chain: 'base', // or 'solana', 'polygon'
  success_url: 'https://...',
  cancel_url: 'https://...',
  metadata: { order_id: '123' }, // optional
});

// Retrieve a session
const session = await checkout.sessions.retrieve('cs_xxx');

// List sessions
const sessions = await checkout.sessions.list({ limit: 10 });
```

### Payments

```typescript
// Get a payment
const payment = await checkout.payments.retrieve('pay_xxx');

// List all payments
const payments = await checkout.payments.list({ limit: 50 });
```

### Webhooks

```typescript
import express from 'express';

app.post('/webhook', express.raw({ type: 'application/json' }), (req, res) => {
  const signature = req.headers['x-checkout-signature'];
  
  try {
    const event = checkout.webhooks.constructEvent(
      req.body.toString(),
      signature,
      process.env.WEBHOOK_SECRET
    );
    
    switch (event.event) {
      case 'payment.succeeded':
        const paymentData = event.data;
        // Fulfill the order
        break;
      case 'payment.failed':
        // Handle failed payment
        break;
    }
    
    res.json({ received: true });
  } catch (err) {
    res.status(400).send(`Webhook Error: ${err.message}`);
  }
});
```

## Configuration

```typescript
const checkout = new Checkout({
  apiKey: 'ck_test_xxx',
  baseUrl: 'https://api.checkout.example.com', // optional
  timeout: 30000, // optional, in milliseconds
});
```

## TypeScript

Full TypeScript support is included. Import types as needed:

```typescript
import type { SessionCreateParams, Payment } from '@stble/sdk';
```

## Test vs Live Mode

- **Test mode keys** start with `ck_test_` - use testnet networks (Base Sepolia, Solana Devnet)
- **Live mode keys** start with `ck_live_` - use mainnet networks

## License

MIT