open-index/open-npm huggingface dataset:
npm package: @neshca/json-replacer-reviver
Description: Utility library for handling `Buffer` object serialization and deserialization with JSON, offering base64 representations
Author: Arseny Kruglikov
Latest version: 1.1.3

# @neshca/json-replacer-reviver

Utility library for handling `Buffer` object serialization and deserialization with JSON, offering base64 representations.

[![npm package](https://img.shields.io/npm/v/@neshca/json-replacer-reviver/latest.svg)](https://www.npmjs.com/package/@neshca/json-replacer-reviver)
[![Dependencies](https://img.shields.io/npm/dm/@neshca/json-replacer-reviver)](https://www.npmjs.com/package/@neshca/json-replacer-reviver)
[![License](https://img.shields.io/npm/l/express.svg)](https://github.com/caching-tools/next-shared-cache/blob/canary/packages/json-replacer-reviver/LICENSE)

## Installation

```bash
npm i @neshca/json-replacer-reviver
```

## Usage

```js
const buffer = Buffer.from('hello');
console.log(buffer); // <Buffer 68 65 6c 6c 6f>

const json = JSON.stringify(buffer);
console.log(json); // '{"type":"Buffer","data":[104,101,108,108,111]}'

const parsed = JSON.parse(json, reviveFromJsonRepresentation);
console.log(parsed); // <Buffer 68 65 6c 6c 6f>
```

```js
const buffer = Buffer.from('hello');
console.log(buffer); // <Buffer 68 65 6c 6c 6f>

const jsonBase64 = JSON.stringify(buffer, replaceJsonWithBase64);
console.log(jsonBase64); // '{"type":"BufferBase64","data":"aGVsbG8="}'

const parsedFromBase64 = JSON.parse(jsonBase64, reviveFromBase64Representation);
console.log(parsed); // <Buffer 68 65 6c 6c 6f>
```

## Developing and contributing

[Developing and contributing to this monorepo](../../docs/contributing/monorepo.md)

### Running tests locally

```bash
npm run test -w ./packages/json-replacer-reviver
```

## License

[MIT](./LICENSE)
npm package: @neshca/server
Description: Efficient and simple HTTP caching server with LRU eviction, tailored for seamless integration with `@neshca/cache-handler/server` Handler
Author: Arseny Kruglikov
Latest version: 1.1.2
Deprecated: Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.

## `@neshca/server`

Efficient and simple HTTP caching server with LRU eviction, tailored for seamless integration with `@neshca/cache-handler/server` Handler.

### Overview

This project provides a simple HTTP server that works seamlessly with `@neshca/cache-handler/server`. It implements an efficient LRU (Least Recently Used) key eviction policy, ensuring optimal use of cache resources by automatically removing the least recently accessed items when the cache reaches its capacity.

### Usage

You can see examples of how to use `@neshca/server` in [Remote HTTP server with LRU cache ↗](https://caching-tools.github.io/next-shared-cache/server) section of the `@neshca/cache-handler` documentation.
npm package: @nesjs/core
Description: [![npm version](https://badge.fury.io/js/%40nesjs%2Fcore.svg)](https://badge.fury.io/js/%40nesjs%2Fcore)
Author: taiyuuki
Latest version: 2.6.3

# @nesjs/core - NES Emulator Core Library

[![npm version](https://badge.fury.io/js/%40nesjs%2Fcore.svg)](https://badge.fury.io/js/%40nesjs%2Fcore)

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A complete NES (Nintendo Entertainment System) emulator core library that provides full NES hardware emulation functionality, UI framework agnostic.

## Features

- 🎮 Complete NES hardware emulation (CPU, PPU, APU)
- 🎯 Support for multiple Mappers
- 🎵 Audio output support
- 🕹️ Dual controller support
- 💾 Save/Load state functionality
- 🔧 Cheat code support
- 🎨 Customizable renderer and audio interfaces
- 📝 TypeScript support

## ROM Compatibility

Supported Mappers: 0, 1, 2, 3, 4, 5, 7, 9, 10, 11, 15, 16, 18, 19, 21, 22, 23, 24, 25, 26, 30, 31, 33, 34, 36, 38, 39, 41, 47, 48, 58, 60, 61, 62, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 78, 79, 85, 86, 88, 87, 89, 92, 93, 94, 97, 107, 112, 113, 115, 118, 119, 129, 140, 152, 154, 169, 180, 182, 184, 185, 195, 200, 201, 203, 206, 212, 213, 214, 225, 226, 228, 229, 231, 240, 241, 242, 244, 245, 246, 248, 249, 255.

## Installation

```bash
npm install @nesjs/core
```

## Quick Start

### Basic Usage

```typescript
import { NES } from '@nesjs/core'

// Create NES instance
const nes = new NES({
    audioSampleRate: 44100,
    audioBufferSize: 1024,
    enableCheat: true
})

// Implement renderer interface
class MyRenderer {
    renderFrame(imageData: Uint8Array) {
        // Handle 256x240 RGBA image data
        console.log('Frame data:', imageData.length) // 245760 bytes
    }
}

// Implement audio interface
class MyAudioOutput {
    outputSample(sample: number) {
        // Handle audio sample data
    }
    
    flushFrame() {
        // Flush audio frame
    }
}

// Set interfaces
nes.setRenderer(new MyRenderer())
nes.setAudioInterface(new MyAudioOutput())

// Load ROM
const romData = new Uint8Array(/* ROM file data */)
await nes.loadROM(romData)

// Run emulator
function gameLoop() {
    nes.runFrame()
    requestAnimationFrame(gameLoop)
}
gameLoop()
```

Refer to [document](https://nesjs.netlify.app/guide/core) for more details.
npm package: @nesk/rialto
Description: Manage Node resources from PHP
Author: Johann Pardanaud
Latest version: 1.4.0

# Rialto

[![PHP Version](https://img.shields.io/packagist/php-v/nesk/rialto.svg?style=flat-square)](http://php.net/)
[![Composer Version](https://img.shields.io/packagist/v/nesk/rialto.svg?style=flat-square&label=Composer)](https://packagist.org/packages/nesk/rialto)
[![Node Version](https://img.shields.io/node/v/@nesk/rialto.svg?style=flat-square&label=Node)](https://nodejs.org/)
[![NPM Version](https://img.shields.io/npm/v/@nesk/rialto.svg?style=flat-square&label=NPM)](https://www.npmjs.com/package/@nesk/rialto)
[![Build Status](https://img.shields.io/travis/nesk/rialto.svg?style=flat-square&label=Build%20Status)](https://travis-ci.org/nesk/rialto)

A package to manage Node resources from PHP. It can be used to create bridges to interact with Node libraries in PHP, like [PuPHPeteer](https://github.com/nesk/puphpeteer/).

It works by creating a Node process and communicates with it through sockets.

## Requirements and installation

Rialto requires PHP >= 7.1 and Node >= 8.

Install it in your project:

```shell
composer require nesk/rialto
npm install @nesk/rialto
```

## Usage

See our tutorial to [create your first bridge with Rialto](docs/tutorial.md).

An [API documentation](docs/api.md) is also available.

## License

The MIT License (MIT). Please see [License File](LICENSE) for more information.
npm package: @neslinesli93/mozjpeg-wasm
Description: WASM wrapper of mozjpeg-sys, exposing functions to re-encode JPEG images and apply transformations to them
Author: Tommaso Pifferi
Latest version: 2.0.1

# mozjpeg-wasm

![npm (scoped)](https://img.shields.io/npm/v/@neslinesli93/mozjpeg-wasm)

This library wraps [`mozjpeg-sys`](https://github.com/kornelski/mozjpeg-sys) and exposes a few functions to perform decoding, encoding and simple transformation on JPEG images using [`mozjpeg`](https://github.com/mozilla/mozjpeg).

Everything is compiled to WebAssembly and bundled in an NPM package which can be used directly in a browser.

## Install

```sh
$ npm i @neslinesli93/mozjpeg-wasm
```

## Usage

The library contains two files:

- `mozjpeg-wasm.wasm`: it's the WebAssembly bundle that exposes all the functions to perform operations on JPEG images
- `mozjpeg-wasm.js`: it exposes JS glue code that can be used to call the functions defined in the WebAssembly module

An example on the usage can be seen inside the [JPEG.rocks repo](https://github.com/neslinesli93/jpeg.rocks/tree/master/src/converter)

## Build from source

Prerequisites:

1. Emscripten (>= `1.39.20`)
2. Rust (>= `1.48.0`)
3. Rust target `wasm32-unknown-emscripten`

Then you can use the following script which builds the crate using `wasm32-unknown-emscripten` target and move the resulting js/wasm files to `lib`:

```sh
$ ./build.sh
```
npm package: @nesn/commons-cache-tools
Description: A flexible caching library that provides both in-memory and Redis-based caching solutions.
Author: Lance Sims, Bob Barber
Latest version: 1.0.4

# Cache Tools

A flexible caching library that provides both in-memory and Redis-based caching solutions.

## Installation

```bash
npm install @nesn/commons-cache-tools
```

## Features

- In-memory caching
- Redis/Elasticache support
- TTL (Time-To-Live) support
- Key prefixing
- Singleton pattern for Redis connections

## Usage

### ElasticacheCache

```typescript:packages/cache-tools/README.md
import { ElasticacheCache } from '@nesn/commons-cache-tools';

// Initialize cache
const cache = new ElasticacheCache('localhost', 6379);

// Set a value (with optional TTL in seconds)
await cache.set('key', 'value');                    // default 60s TTL
await cache.set('key', 'value', 'prefix');          // with prefix
await cache.set('key', 'value', undefined, 3600);   // 1 hour TTL

// Get a value
const value = await cache.get('key');               // returns 'value' or null
const prefixedValue = await cache.get('key', 'prefix');

// Delete a value
await cache.delete('key');
await cache.delete('key', 'prefix');
```

### InMemoryCache

```typescript
import { InMemoryCache } from '@nesn/commons-cache-tools';

const cache = new InMemoryCache();

// Same interface as ElasticacheCache
await cache.set('key', 'value');
const value = await cache.get('key');
await cache.delete('key');

```packages/cache-tools/README.md

## Interface

Both caching implementations follow the `Cache` interface:

```typescript
interface Cache {
    set(key: string, value: string, prefix?: string, ttl?: number): Promise<void>;
    get(key: string, prefix?: string): Promise<string | null>;
    delete(key: string, prefix?: string): Promise<void>;
}
```

## Error Handling

- ElasticacheCache automatically logs Redis client errors to console.error
- Failed operations will reject their promises
- Non-existent keys return null

## Best Practices

1. Reuse cache instances when possible
2. Use meaningful key prefixes to avoid collisions
3. Set appropriate TTLs to prevent stale data
4. Handle async operations appropriately with try/catch blocks

## License

MIT
npm package: @nesn/commons-cognito-tools
Description: Cognito tools
Author: Lance Sims
Latest version: 1.0.3

# @nesn/commons-cognito-tools

## Overview

`@nesn/commons-cognito-tools` is a utility package designed to simplify interactions with AWS Cognito. It provides functions to manage and query Cognito users efficiently.

## Installation

To install the package, use npm:


## Usage

### Finding a Cognito User by Filter

You can use the `findCognitoUserByFilter` function to find a user in a Cognito user pool by a specific filter.

```ts
import { findCognitoUserByFilter } from '@nesn/commons-cognito-tools';

const user = await findCognitoUserByFilter(
    CognitoFilterType.EMAIL,
    'user@example.com',
    'user-pool-id',
    {
        region: 'your-region',
        credentials: {
            accessKeyId: 'your-access-key-id',
            secretAccessKey: 'your-secret-access-key',
            sessionToken: 'your-session-token'
        }
    }
);

```

## API

### `findCognitoUserByFilter(filterType, filterValue, userPoolId, clientOptions)`

- **filterType**: `CognitoFilterType` - The type of filter to apply (e.g., EMAIL, USERNAME).
- **filterValue**: `string` - The value to filter by.
- **userPoolId**: `string` - The ID of the Cognito user pool.
- **clientOptions**: `object` - AWS client configuration options.

Returns a `Promise` that resolves to a `CognitoUser` object or `null` if no user is found.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
npm package: @nesn/commons-lambda-logger
Description: A compact logger that works in both commonJS and ES module projects.
Author: Lance Sims
Latest version: 1.0.20

# NESN LAMBDA LOGGER

A compact logger that works in both commonJS and ES module projects.

## Usage
```js
// CommonJS
const { lambdaLogger } = require('@nesn/lambda-logger');

// ES Modules
import { lambdaLogger } from '@nesn/lambda-logger';

lambdaLogger.info|error|warn(message:string, meta:Record<string, any>, ...tags | null);
```

## Example
```js
// CommonJS
const { lambdaLogger } = require('@nesn/lambda-logger');

// ES Modules
import { lambdaLogger} from '@nesn/lambda-logger';

lambdaLogger.info | error | warn('Your log message here', {
    metadata: 'goes here',
    nested: {
        objects: {
            description: 'are okay as well'
        },
        example: {
            user: {
                email: 'me@here.com',
                name: 'Some Juan'
            }
        }
    } // Use any number of LogTags
}, 'tag_1', 'tag_two', 'tag_3');
```

```text
Field	Value
@ingestionTime	1690917057370
@log	837502413404:/aws/lambda/<your-lambda-and-log-group>
@logStream	2023/08/01/[$LATEST]11221d14ce6c4c5ea715d4255fec83e0
@message	2023-08-01T19:10:52.522Z	2d82aa0d-915e-4d27-b21c-efc055cdef03	INFO	THIS IS A MESSAGE FROM STANDARD WINSTON LOGGER {"email":"me@here.com","nested":{"foo":{"id":"0u812"}},"tags":"get_user_tag,entitlement_tag,ip_lookup_tag"}
@requestId	2d82aa0d-915e-4d27-b21c-efc055cdef03
@timestamp	1690917052522
nested.objects.description are okay as well
nested.example.user.email	me@here.com
nested.example.user.name	Some Juan
tags	tag_1,tag_two,
```
npm package: @nesn/commons-sqs-tools
Description: This is a helper module for SQS handler, It provides configurable retry and error handling features for the handler, let devs focus on the logic of processing message.
Author: Paul Peng
Latest version: 1.5.0

# SQS Tools Module Readme

This is a helper module for SQS handler, It provides configurable retry and error handling features for the handler, let devs focus on the logic of processing message.

## Table of Contents

-   [Introduction](#introduction)
-   [Installation](#installation)
-   [Usage](#usage)
    -   [Importing](#importing)
    -   [Wrap the handler](#wrap-the-handler)
-   [Customization](#customization)
-   [Contributing](#contributing)
-   [License](#license)

## Introduction

Enable a message handler to do the following automatically

-   process batched messages in parallel
-   set retry interval
-   delete message on success
-   throw error on fail
-   return messageIds of failed messages to trigger a partial retry

## Installation

To include the `@nesn/commons-sqs-tools` module in your project, you can install it using npm:

```bash
npm install @nesn/commons-sqs-tools
```

## Usage

### Importing

```typescript
import { batchedMessageHandler } from '@nesn/commons-sqs-tools';
```

### Wrap the handler

```typescript
import { batchedMessageHandler } from '@nesn/commons-sqs-tools';

const mainHandler = (sqsEvent) => {
    // main logic done in here
};

export const handler = batchedMessageHandler({
    handler: mainHandler,
    retryStages: [
        { attempts: 3, interval: 30 }, // unit: second
        { attempts: 2, interval: 60 },
        { attempts: 1, interval: 120 }
    ],
    clientConfig: {
        credentials: {}, // overwrite credential if needed
        endpoint: '' // useful when local debug, local sqs endpoint can be set in here
    }
});
```

## Customization

The `@nesn/commons-sqs-tools` module provides a default retry and error handling features for your handler. You can extend or modify it to suit your project's needs.

## Contributing

Contributions to the `@nesn/commons-sqs-tools` module are welcome. If you encounter any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request.

## License

The `@nesn/commons-sqs-tools` module is released under the MIT License. You can find the full license text in the module's `package.json` file.

---

_Please note that this readme is provided as an example and might need adjustments based on your specific project and documentation guidelines._
npm package: @nesn/commons-system-health-tools
Description: `@nesn/commons-system-health-tools` is a utility package designed to facilitate the creation and management of AWS CloudWatch alarms and tags. It provides functions to build alarm tags based on system health configurations, making it easier to monitor app
Author: Paul Peng
Latest version: 1.1.0

# @nesn/commons-system-health-tools

## Overview

`@nesn/commons-system-health-tools` is a utility package designed to facilitate the creation and management of AWS CloudWatch alarms and tags. It provides functions to build alarm tags based on system health configurations, making it easier to monitor application performance.

## Installation

To install the package, use npm:

```sh
npm install @nesn/commons-system-health-tools
```

## Usage

### Building System Health CloudWatch Alarm Tags

You can use the `buildSystemHealthCloudwatchAlarmTags` function to create an array of tags for AWS CloudWatch alarms based on a provided configuration.

In `serverless.json` file

```ts
import { buildSystemHealthCloudwatchAlarmTags } from '@nesn/commons-system-health-tools';

export const serverlessConfiguration = {
    resources: {
        Resources: {
            TestAlarm: {
                Type: 'AWS::CloudWatch::Alarm',
                Properties: {
                    AlarmDescription: 'Monitor errors in the test function',
                    Namespace: 'AWS/Lambda',
                    MetricName: 'Errors',
                    Dimensions: [
                        {
                            Name: 'FunctionName',
                            Value: '${self:service}-${self:provider.stage}-test'
                        }
                    ],
                    Statistic: 'Sum',
                    Period: 60,
                    EvaluationPeriods: 1,
                    Threshold: 1,
                    ComparisonOperator: 'GreaterThanOrEqualToThreshold',
                    TreatMissingData: 'missing',
                    Tags: buildSystemHealthCloudwatchAlarmTags({
                        env: '${self:provider.stage}', // '${self:provider.stage}' will be resolved dynamically by serverless
                        componentName: 'testFunction',
                        indicatorName: 'error'
                    })
                }
            }
        }
    }
};
```

## API

### `buildSystemHealthCloudwatchAlarmTags(config)`

-   **config**: `SystemHealthAlarmTagConfig` - An object containing the configuration for the tags. It should include:
    -   **env**: `string` - The environment (e.g., prod, qa, dev).
    -   **componentName**: `string` - The name of the component or service (e.g., database, redis, stripe).
    -   **indicatorName**: `string` - The name of the health indicator (e.g., CPUUtilization, latency).

Returns an array of `Tag` objects that can be used with AWS CloudWatch alarms.

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
npm package: @neso.io/material-dashboard
Description: The default blueprint for ember-cli addons.
Latest version: 0.0.5

material-dashboard
==============================================================================

[Short description of the addon.]

Installation
------------------------------------------------------------------------------

```
ember install material-dashboard
```


Usage
------------------------------------------------------------------------------

[Longer description of how to use the addon in apps.]


Contributing
------------------------------------------------------------------------------

### Installation

* `git clone <repository-url>`
* `cd material-dashboard`
* `npm install`

### Linting

* `npm run lint:js`
* `npm run lint:js -- --fix`

### Running tests

* `ember test` – Runs the test suite on the current Ember version
* `ember test --server` – Runs the test suite in "watch mode"
* `npm test` – Runs `ember try:each` to test your addon against multiple Ember versions

### Running the dummy application

* `ember serve`
* Visit the dummy application at [http://localhost:4200](http://localhost:4200).

For more information on using ember-cli, visit [https://ember-cli.com/](https://ember-cli.com/).

License
------------------------------------------------------------------------------

This project is licensed under the [MIT License](LICENSE.md).
npm package: @nesoi/plugin-postgres
Description: PostgreSQL plugin for the nesoi framework
Author: Hugo Aboud
Latest version: 3.4.14

# @nesoi/plugin-postgres

[PostgreSQL](https://www.postgresql.org/) plugin for the [nesoi](https://github.com/nesoi-org/nesoi) framwork, built with [Postgres.js](https://github.com/porsager/postgres).

## Install

```
npm i @nesoi/plugin-postgres
```

## Usage

- [Tutorial](docs/TUTORIAL.md)
- [Example](docs/example)
- [API Reference](docs/api/index.html)
npm package: @nesoi/plugin-s3
Description: AWS S3 plugin for the nesoi framework
Author: Hugo Aboud
Latest version: 3.3.2

# @nesoi/s3

[AWS S3](https://aws.amazon.com/s3/) plugin for the [nesoi](https://github.com/nesoi-org/nesoi) framwork, built with [aws-sdk-js](https://github.com/aws/aws-sdk-js).

## Install

```
npm i @nesoi/s3
```

## Usage

- [Tutorial](docs/TUTORIAL.md)
- [Example](docs/example)
- [API Reference](docs/api/index.html)
npm package: @nesorter/discord-stream-lib
Description: Discord bot for playing music from web-radio
Author: kugichka
Latest version: 1.0.15

# nesorter-discord
## Discord bot for playing music from web-radio

### Requirements
- `ffmpeg` installed on host and available in $PATH
- your bot added to server where you want restream music

### Helpful Links
- [Getting a Discord Bot Token](https://github.com/moonstar-x/discord-downtime-notifier/wiki/Getting-a-Discord-Bot-Token)
- [Adding Your Bot To Your Server](https://github.com/moonstar-x/discord-downtime-notifier/wiki/Adding-Your-Bot-To-Your-Server)
- [Getting User, Channel and Server IDs](https://github.com/moonstar-x/discord-downtime-notifier/wiki/Getting-User,-Channel-and-Server-IDs)
### How to use

- Init Node.JS package/project
```bash
mkdir radio-restream && \
cd radio-restream && \
npm init -f
```

- Next, install this lib
```bash
npm install @nesorter/discord-stream-lib@latest
```

- Next, create `index.js` and paste this code:
```js
const { Bot } = require('@nesorter/discord-stream-lib');

Bot({
  // bot token, yeah
  BOT_TOKEN: 'secret', 

  // custom name for bot
  BOT_SELF_RENAME_TO_NAME: 'restream', 

  // id of voice chat where bot streams music
  VOICE_CHAT_ID: '529772279727652864', 

  // url to your web-radio
  STREAM_MOUNTPOINT: 'http://kugi.club:3002/listen',

  // custom idv3 tags injecting to discord bot profile
  onTrackMetadataRequested: async () => {
    // here you can call external api, ex:
    // const data = await axios('http://radio.com/api/current');

    return {
      artist: 'Artist 2',
      title: 'Title 2',
    };
  },
}).then(({ client, audioPlayer, audioResource }) => {
  // this callback will be called when init done
  // here you can control bot and audio by yourself (if you need), so:

  // client - https://old.discordjs.dev/#/docs/discord.js/main/class/Client
  // audioPlayer - https://discord.js.org/docs/packages/voice/main/AudioPlayer:Class
  // audioResource - https://discord.js.org/docs/packages/voice/main/AudioResource:Class
});
```

- So, start app with:
```bash
node index.js
```
npm package: @nesorter/lib
Description: Standalone solution for audio streaming
Author: kugichka
Latest version: 1.0.18

# @nesorter/lib
### Standalone solution for audio streaming
Set of utils for audio streaming

### Usage example
```typescript
import { Streamer, FileSystemScanner, Queue } from '@nesorter/lib';

// with this options webradio should be available
// on 'http://localhost:3000/listen'
const streamer = new Streamer(3000, '/listen');

// sets root path for scanning audio library
const scanner = new FileSystemScanner('/home/user/music');

// create play queue
const queue = new Queue(streamer);

// compose all: scan-audio-lib -> add-to-queue -> start-queue
scanner.scan()
  .then((items) => items.map((item) => queue.add(item.fullPath)))
  .then(() => queue.startQueue());
```
npm package: @nesorter/tui
Description: Terminal UI for @nesorter/lib
Author: kugichka
Latest version: 1.1.5

# nesorter
## Web radio with scheduling and "playlisting"

### Requirements
- `ffprobe` installed on host and available in $PATH

### How to use
- Init Node.JS package/project
```bash
mkdir radio && \
cd radio && \
npm init -f
```

- Make sure your `package.json` contains `"type": "module"`

- Next, install this app
```bash
npm install @nesorter/tui@latest
```

- Next, create `index.js` and paste this code:
```js
import { TUI } from '@nesorter/tui';

const config = {
  server: {
    port: 3000,
    mount: '/listen',
  },
  logger: {
    debug: false,
    info: true,
  },
  library: {
    root: '/Users/kugichka/Music/Electronics Random',
  },
  playlists: [
    {
      id: 'random #1',
      path: '/Users/kugichka/Music/Electronics Random/Random #1 > kugi\'s'
    },
    {
      id: 'random #2',
      path: '/Users/kugichka/Music/Electronics Random/Random #2 > kugi\'s'
    },
  ],
  maxScheduledItems: 256,
  schedule: [{
    type: 'playlist',
    startAt: 0, // 00:00
    duration: 86400, // 24 hours
    playlistId: 'random #1',
    shouldShuffle: true,
  }],
};

TUI.create(config).start().then(() => {
  console.log('Event: server initialized');
});
```

- So, start app with:
```bash
node index.js
```