open-index/open-npm huggingface dataset:
npm package: @isluny/bitfields
Description: ```ts class GroupPermissions extends bitfields.Bitfield<typeof GroupPermissions['Flags']> {     static Flags = {         'create:post_content': bitfields.bit(0), // (1n << 0n) -> 0n,         'read:post_content': bitfields.bit(1), // (1n << 1n) -> 1n,     
Author: JVOPINHO
Latest version: 1.0.5

# 🧮 @isluny/bitfields

## Creating a Bitfield Set
### 🟦 TypeScript
```ts
class GroupPermissions extends bitfields.Bitfield<typeof GroupPermissions['Flags']> {
    static Flags = {
        'create:post_content': bitfields.bit(0), // (1n << 0n) -> 0n,
        'read:post_content': bitfields.bit(1), // (1n << 1n) -> 1n,
        'update:members': bitfields.bit(2), // (1n << 2n) -> 2n,
        'update:group': bitfields.bit(3), // (1n << 3n) -> 4n,
    }

    static defaultBits = GroupPermissions.resolve<typeof GroupPermissions['Flags']>(
        'create:post_content',
        'read:post_content'
    )
}
```

## Using Bitfield
```ts
const permissions = new GroupPermissions()
```

## Methods

### `has(bit: Bit<Flags>): boolean`
Checks if a specific bit is set.

```ts
permissions.has('create:post_content') // true or false
```

### `add(...bits: Bit<Flags>): this`
Adds one or more bits to the bitfield.

```ts
permissions.add('update:members')
```

### `remove(...bits: Bit<Flags>): this`
Removes one or more bits from the bitfield.

```ts
permissions.remove('create:post_content')
```

### `serialize(): Record<Keys<Flags>, boolean>`
Returns an object representing the bitfield flags as key-value pairs.

```ts
console.log(permissions.serialize())
```

### `toArray(): Array<Keys<Flags>>`
Returns an array of all enabled flags.

```ts
console.log(permissions.toArray())
```

### `toJSON(): number`
Returns the numerical representation of the bitfield.

```ts
console.log(permissions.toJSON())
```

### Iterating Over Flags
You can iterate over a bitfield instance to get all active flags.

```ts
for (const flag of permissions) {
    console.log(flag)
}
```

## Conclusion
`@isluny/bitfields` provides an efficient and flexible way to manage permissions and feature flags using bitfields. Whether you're handling user roles, access permissions, or other flag-based systems, this package offers an intuitive API with TypeScript support. 🚀
npm package: @isluny/deck-cards
Description: A basic package for generating card decks and managing basic usage logic.
Author: JVOPINHO
Latest version: 1.0.3

# 🃏 Deck Cards

A basic package for generating card decks and managing basic usage logic.

## Installation
```
npm i @isluny/deck-cards
```

## Creating & Using a Deck

### Starting
Create a basic deck
```js
const { Deck } = require('@isluny/deck-cards')

const deck = new Deck()
```

| Parameter                 | Type                                                                                    | Optional? | Default | Descrirption                                                                         |
|---------------------------|-----------------------------------------------------------------------------------------|-----------|---------|--------------------------------------------------------------------------------------|
| options.numberOfFullDecks | `number`                                                                                | `true`    | `1`     | Number of full decks                                                                 |
| options.allowedValues     | [`CardValue`](https://github.com/IsLunyStudios/deck-cards/blob/main/src/card.ts#L8)`[]` | `true`    | ---     | If defined, there will only be cards with the specified values ​​in the deck         |
| options.autoShuffle       | `boolean`                                                                               | `true`    | `true`  | If true, when the deck is created or reset, the cards will be shuffled automatically |

### Methods
#### Draw
Get the first card on top
```js
const card = deck.draw()
```

### Draw Many
Returns a array with top cards from the deck.
```js
const cards = deck.drawMany(3)
```

### Shuffle
We can shuffle the deck and randomize the positions
```js
deck.shuffle()
```

### Disable a Card
You can disable the use of a card in the deck
```
deck.disableCard(`${CardValue.Ace}:${CardSuit.Spades}`);
```

[CardValue Enum](https://github.com/IsLunyStudios/deck-cards/blob/main/src/card.ts#L8) | [CardSuit Enum](https://github.com/IsLunyStudios/deck-cards/blob/main/src/card.ts#L1)

### Get number of card available
```js
const deckAvailable = deck.len()
```

### Get number of card used
```js
const deckUsed = deck.used()
```
npm package: @ismael01866/design-system-boilerplate
Description: Simple design system boilerplate
Author: Ismael Mariscal
Latest version: 1.1.1

# Design System Boilerplate

## Table of Contents

1. [Requirements](#1-requirements)
2. [Quick Start](#2-quick-start)

## 1. Requirements

The boilerplate needs [Node.js](https://nodejs.org/en/) to be installed on your system.
It was tested with version 16 and newer.

## 2. Quick Start

1. Clone the repository into a new folder for your new project.

   ```bash
   git clone git@github.com:ismael01866/design-system-boilerplate.git
   ```

2. Install dependencies

   ```bash
   npm install
   ```

3. Run webpack

   ```bash
   npm run build
   ```

   This command tells webpack to run in production mode and compiles all of the assets in a minified version, ready to be delivered as production assets.