open-index/open-npm huggingface dataset:
npm package: @moonandyou/chrome-path
Description: Getting path for chromium / chrome, it returns paths of chromium / chrome installed on your system
Author: ragingwind
Latest version: 0.2.1

# chrome-path

> Getting path for chromium / chrome, it returns paths of chromium / chrome installed on your system

## Install

```
$ yarn add @moonandyou/chrome-path

or

$ npm install @moonandyou/chrome-path
```

# Usage

```js
const chromePath = require('@moonandyou/chrome-path');

chromePath().then(res => console.log(res));
//=> { 'google-chrome': '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', 'google-chrome-canary': '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary', chromium: '/Applications/Chromium.app/Contents/MacOS/Chromium' }
```

## License

MIT © [Jimmy Moon](http://ragingwind.me)
npm package: @moonandyou/chrome-path-cli
Description: Getting path for chromium/chrome, it returns paths of chromium/chrome installed on your system
Author: Jimmy Moon
Latest version: 0.2.1

# chrome-path-cli

> Getting path for chromium/chrome, it returns paths of chromium/chrome installed on your system

## Install

```sh
$ npm install --global @moonandyou/chrome-path-cli
```

## Usage

```sh
# path of chromes and output json
$ chrome-path --json --chrome --canary --chromium
{
  "chrome": "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
  "canary": "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
  "chromium": "/Applications/Chromium.app/Contents/MacOS/Chromium"
}

# path of chrome canary only
$ chrome-path --chrome --canary --chromium
/Applications/Google Chrome.app/Contents/MacOS/Google Chrome
/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary
/Applications/Chromium.app/Contents/MacOS/Chromium

# chrome is default. output as json
$ chrome-path --json

# and more
$ chrome-path --help
```

## License

MIT © [Jimmy Moon](http://ragingwind.me)
npm package: @moonandyou/symlinks
Description: Create symlinks in a safe way
Author: ragingwind
Latest version: 0.1.6

# symlinks [![Build Status](https://travis-ci.org/ragingwind/symlinks.svg?branch=master)](https://travis-ci.org/ragingwind/symlinks)

> Create symlinks in a safe way


## Install

```
$ npm install --save symlinks
```


## Usage

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

symlinks(['~/.dotfiles/**/*', '~/Downloads/local/*'], $HOME).then(links) {
}

const hidden = f => `.${path.basename(f, path.extname(f))}`;
symlinks(['~/.dotfiles/**/*', '~/Downloads/local/*'], $HOME).then(links) {
    // will be linked after named .filename
}
```

## API

### symlinks(patterns, dest, [options])

Return a Promise for an array of creating symbolic links

#### patterns

Type: `string` or `array`

Pattern of [globby](https://github.com/sindresorhus/globby) for Source files to become a symbolic link, 

#### dest

Type: `string`

Path for root directory for symbolic links

#### options

##### unlink

Type: `boolean`<br>
Default: `false`

Whether unlink exists symbolic link or not

##### verbose

Type: `boolean`<br>
Default: `false`

Show a progress

## License

MIT © [MOONANDYOU](http://moonandyou.com)
npm package: @moonandyou/symlinks-cli
Description: CLI for creating symlinks in a safeway
Author: ragingwind
Latest version: 0.3.3

# symlinks [![Build Status](https://travis-ci.org/mooonandyou/symlinks.svg?-clibranch=master)](https://travis-ci.org/mooonandyou/symlinks)-cli

> CLI for creating symlinks in a safeway


## Install

```
$ npm install --global @moonandyou/symlinks-cli
```

## Help

```
$ sn --help
```

## License

MIT © [MOONANDYOU](http://moonandyou.com)
npm package: @moonba/swap-core-contracts
Description: Core contracts for DEX deployment built on Uniswap V2
Author: m-bo-one
Latest version: 1.0.0

# Swap core contracts

This project deploy DEFI contracts based on Uniswap V2

### How to launch
Prerequisites: node.js v.11.4.0+ is required
1. Install dependencies:
```yarn```
2. Deploy factory and router contracts:
```
hh deploy --network frankenstein
```
3. (optionally) Add fee address for com swap (after this, mechanics will be 0.25% + 0.05% for feeTo):
```
hh run --network frankenstein src/setFeeTo.ts
```

In order to create a new project from this, MoonbaLibrary should be updated with init code hash.
It could be generated from this command:
```
hh run src/generateInitCode.ts
```
npm package: @moonbase.sh/api
Description: Package to let you integrate backends with Moonbase.sh as payment and delivery provider
Author: Tobias Lønnerød Madsen
Latest version: 1.0.17

# @moonbase.sh/api

Server-side Moonbase SDK for managing products, orders, subscriptions, licenses, trials, vouchers, customers, and activation requests.

This is a wrapper around our core API, with official documentation here: https://moonbase.sh/docs/api/

## Install

```bash
pnpm add @moonbase.sh/api
```

## Create a client

```ts
import { MoonbaseClient } from '@moonbase.sh/api'

const client = new MoonbaseClient({
  endpoint: process.env.MOONBASE_ENDPOINT!,
  apiKey: process.env.MOONBASE_API_KEY!,
})
```

- `endpoint` is your Moonbase account URL (for example `https://demo.moonbase.sh`).
- `apiKey` is a secret and should only be used from your backend.

## Common usage

### Query products with pagination

```ts
const firstPage = await client.products.query({
  activeOnly: true,
  pageSize: 20,
})

console.log(firstPage.items)

if (firstPage.hasMore) {
  const secondPage = await firstPage.getNext()
  console.log(secondPage.items)
}
```

### Prepare an order for checkout

```ts
const order = await client.orders.prepare(
  {
    currency: 'EUR',
    items: [
      {
        type: 'Product',
        productId: 'moon-terminal',
        quantity: 1,
      },
    ],
  },
  'https://your-app.example/checkout-complete',
)

console.log(order.id, order.status)
```

### Manage licenses

```ts
const page = await client.licenses.query({ pageSize: 10 })

const provisioned = await client.licenses.provision({
  customer: {
    name: 'Jane Doe',
    email: 'jane@example.com',
  },
  requests: [
    {
      productId: 'moon-terminal',
      quantity: 1,
    },
  ],
})

await client.licenses.revoke(provisioned[0].id)
```

## Available endpoint groups

`client.activationRequests`, `client.customers`, `client.licenses`, `client.orders`, `client.products`, `client.subscriptions`, `client.trials`, `client.vouchers`.

## Error handling

Most non-2xx responses are thrown as typed errors:

- `MoonbaseError`
- `NotAuthenticatedError`
- `NotAuthorizedError`
- `NotFoundError`
- `ConflictError`

```ts
import { MoonbaseError, NotFoundError } from '@moonbase.sh/api'

try {
  await client.products.get('unknown-product')
}
catch (error) {
  if (error instanceof NotFoundError) {
    // handle missing entity
  }
  else if (error instanceof MoonbaseError) {
    // generic Moonbase API failure
  }
  else {
    throw error
  }
}
```
npm package: @moonbase.sh/licensing
Description: Package to add sotftware licensing using Moonbase.sh to your node.js apps
Author: Tobias Lønnerød Madsen
Latest version: 1.0.17

# @moonbase.sh/licensing

Node.js licensing SDK for Moonbase products.

Use it to request activation, validate licenses locally and online, persist licenses, and revoke activations.

Learn more in our official documentation here: https://moonbase.sh/docs/licensing/sdks/node/

## Install

```bash
pnpm add @moonbase.sh/licensing
```

## Create a licensing client

```ts
import { FileLicenseStore, MoonbaseLicensing } from '@moonbase.sh/licensing'

const licensing = new MoonbaseLicensing({
  endpoint: 'https://demo.moonbase.sh',
  productId: 'demo-app',
  publicKey: process.env.MOONBASE_PUBLIC_KEY!,
  accountId: process.env.MOONBASE_ACCOUNT_ID,

  // Optionally adjust the license store with path
  // to where the license should be stored, or use
  // alternate storage mechanisms to persist the token.
  licenseStore: new FileLicenseStore(),
})
```

- `publicKey` is the Moonbase public key used to verify signed license tokens.
- `FileLicenseStore` persists the license locally (`license.mb` by default).

## Activation flow

```ts
const request = await licensing.client.requestActivation()

console.log('Open this URL in a browser:', request.browser)

let license = null
while (!license) {
  await new Promise(resolve => setTimeout(resolve, 1000))
  license = await licensing.client.getRequestedActivation(request)
}

await licensing.store.storeLocalLicense(license)
console.log('License stored locally')
```

## Validate on startup

```ts
const localLicense = await licensing.store.loadLocalLicense()

if (localLicense) {
  // Validate token signature + device binding locally
  const locallyValidated = await licensing.validator.validateLicense(localLicense.token)

  // Re-validate against Moonbase (recommended for online activations)
  const refreshed = await licensing.client.validateLicense(locallyValidated)
  await licensing.store.storeLocalLicense(refreshed)
}
```

## Revoke a license activation

```ts
const localLicense = await licensing.store.loadLocalLicense()

if (localLicense) {
  await licensing.client.revokeLicense(localLicense)
  await licensing.store.deleteLocalLicense()
}
```

## Offline helpers

Generate a device token to support offline activation workflows:

```ts
const deviceToken = await licensing.generateDeviceToken()
```

Read and validate raw license bytes (for example from a file):

```ts
const license = await licensing.readRawLicense(rawLicenseBuffer)
```

## Custom stores and device resolvers

You can inject your own `ILicenseStore` and `IDeviceIdResolver` implementations.

Note: the current configuration property name for custom device resolver is `deivceIdResolver`.
npm package: @moonbase.sh/storefront
Description: Package to let you embed Moonbase.sh into your storefront as a payment and delivery provider
Author: Tobias Lønnerød Madsen
Latest version: 1.0.17

# @moonbase.sh/storefront

Embeddable Moonbase storefront widget for browser apps.

This package wraps auth, cart, checkout, voucher redemption, product downloads, activation, and subscription management behind one client-side API.

Learn more about our embedded storefront in our official docs: https://moonbase.sh/docs/storefronts/embedded/

## Install

```bash
pnpm add @moonbase.sh/storefront
```

## Quick start

```ts
import Moonbase, { MoonbaseEvent } from '@moonbase.sh/storefront'

Moonbase.setup('https://demo.moonbase.sh', {
  toolbar: {
    enabled: true,
    location: 'top-right',
  },
})

Moonbase.on(MoonbaseEvent.CheckoutCompleted, ({ order }) => {
  console.log('Order completed', order.id)
})
```

`setup` should be run once, client-side, after the DOM is available.

## Trigger intents

Use intent methods to open specific views or execute actions:

```ts
Moonbase.sign_in({ email: 'jane@example.com' })

Moonbase.add_to_cart({
  product_id: 'my-product',
  quantity: 1,
})

Moonbase.view_cart()
Moonbase.checkout()
Moonbase.view_products()
```

All intents are snake_case methods on the `Moonbase` instance (for example `view_product`, `manage_subscription`, `redeem_voucher`).

## Configure behavior and theme

You can pass options in `setup(...)` and update them later with `configure(...)`:

```ts
Moonbase.configure({
  auth: {
    signUp: {
      enabled: false,
    },
  },
  cart: {
    quantity: 'single',
  },
  theme: {
    colors: {
      primary: '#E5A000',
      background: 'white',
    },
    fonts: {
      heading: 'Aleo',
      body: 'Inter',
    },
  },
})
```

You can also control where the widget mounts by providing `target`.

## Events

Subscribe to widget lifecycle events with `Moonbase.on(...)`.

Available events include:

- `signed-in`
- `signed-up`
- `signed-out`
- `redeemed-voucher`
- `downloaded-product`
- `activated-product`
- `added-to-cart`
- `checkout-initiated`
- `checkout-closed`
- `checkout-completed`
npm package: @moonbase.sh/storefront-api
Description: Package to let you build storefronts with Moonbase.sh as payment and delivery provider
Author: Tobias Lønnerød Madsen
Latest version: 1.0.17

# @moonbase.sh/storefront-api

Browser-first Moonbase SDK for storefront and customer flows: storefront data, identity, carts/orders, vouchers, inventory, and activation requests.
Learn more about our storefront API in our official docs: https://moonbase.sh/docs/storefronts/api/

## Install

```bash
pnpm add @moonbase.sh/storefront-api
```

## Create a client

```ts
import { MoonbaseClient } from '@moonbase.sh/storefront-api'

const client = new MoonbaseClient({
  endpoint: 'https://demo.moonbase.sh',
  persistUtm: true,
})
```

Configuration notes:

- `endpoint`: your Moonbase storefront URL.
- `includeManifests`: include downloadable file manifests when available.
- `persistUtm`: store detected UTM values in localStorage instead of sessionStorage.

## Common usage

### Load storefront and create an order

```ts
const storefront = await client.storefront.get()

const order = await client.orders.pushContent(
  {
    id: crypto.randomUUID(),
    currency: storefront.suggestedCurrency,
    items: [
      {
        type: 'Product',
        productId: storefront.products[0].id,
        variationId: storefront.products[0].defaultVariation?.id ?? '',
        quantity: 1,
      },
    ],
  },
  {
    returnUrl: `${window.location.origin}/checkout-complete`,
  },
)

if (order.checkoutUrl)
  window.location.href = order.checkoutUrl
```

### Sign in a customer

```ts
await client.identity.signIn('jane@example.com', 'password')

const user = await client.identity.get()
console.log(user.email)
```

### Redeem a voucher

```ts
const preview = await client.vouchers.peek('MY-CODE')
console.log(preview)

await client.identity.signIn('jane@example.com', 'password')
const redeemed = await client.vouchers.redeem('MY-CODE')
console.log(redeemed)
```

## Inventory flow

Most inventory endpoints require an authenticated user:

```ts
const products = await client.inventory.products.getOwned()
const licenses = await client.inventory.licenses.get()
```

Pagination on inventory endpoints is done by passing the `next` URL back into the same method:

```ts
let page = await client.inventory.products.getOwned()

while (page.hasMore && page.next) {
  page = await client.inventory.products.getOwned(page.next)
}
```

## Endpoint groups

`client.storefront`, `client.identity`, `client.orders`, `client.vouchers`, `client.inventory`, `client.activationRequests`, `client.vendor`.

## Token storage and logging

By default, credentials are stored in localStorage (or in-memory if localStorage is unavailable).

You can inject your own storage/logger implementations:

```ts
import { ConsoleLogger, InMemoryStore, LogLevel, MoonbaseClient } from '@moonbase.sh/storefront-api'

const client = new MoonbaseClient({
  endpoint: 'https://demo.moonbase.sh',
  store: new InMemoryStore(),
  logger: new ConsoleLogger(LogLevel.Debug),
})
```
npm package: @moonbase.sh/vue
Description: Package to let you build vue.js storefronts with Moonbase.sh as payment and delivery provider
Author: Tobias Lønnerød Madsen
Latest version: 1.0.17

# @moonbase.sh/vue

Vue 3 storefront SDK built on top of `@moonbase.sh/storefront-api`.

It provides a plugin/context plus composables for auth, products, cart, checkout, vouchers, inventory, and activation flows.

Learn more in our official docs: https://moonbase.sh/docs/storefronts/sdks/vue/

## Install

```bash
pnpm add @moonbase.sh/vue
```

Peer dependency:

- `vue@^3.2.0`

## Basic setup (Vue + Vite)

```ts
import { createStorefront } from '@moonbase.sh/vue'
import { createApp } from 'vue'
import App from './App.vue'

const storefront = createStorefront('https://demo.moonbase.sh')

createApp(App)
  .use(storefront)
  .mount('#app')
```

## Use composables in components

```vue
<script setup lang="ts">
import { useAuth, useCart, useProducts } from '@moonbase.sh/vue'

const products = useProducts()
const { user, signIn, signOut } = useAuth()
const cart = useCart()

async function buyFirstProduct() {
  const first = products.value[0]
  if (!first)
    return

  cart.addToCart(first)
  await cart.checkout({ redirect: false })
}
</script>
```

## Main composables

- `useAuth()` - sign in/up/out, profile updates, password/email/account confirmation flows.
- `useProducts()`, `useProduct(id)` - storefront products access.
- `useBundles()`, `useBundle(id)` - storefront bundles access.
- `useCart()` - cart state, totals, add/remove/set quantity, checkout.
- `useCheckout(items, options)` - one-off checkout session without mutating the persistent cart.
- `useInventory()` - owned products/licenses/subscriptions, activation and download helpers.
- `useVoucher()` - voucher peek/redeem.
- `useActivationRequest(token)` - activation request polling + fulfillment helpers.
- `useVendor()` - vendor metadata.

## Nuxt/state management integration

You can pass a custom `stateFactory` to integrate with Nuxt `useState`:

```ts
const storefront = createStorefront(
  'https://demo.moonbase.sh',
  (key, state) => useState(key, () => state),
)

if (process.server)
  await storefront.updateStorefront()
```

## Checkout lifecycle events

The storefront context exposes checkout lifecycle hooks:

```ts
storefront.onCheckoutInitiated((order, total) => {
  console.log('Checkout started', order.id, total)
})

storefront.onCheckoutCompleted((order) => {
  console.log('Checkout completed', order.id)
})
```