open-index/open-npm huggingface dataset:
npm package: @mixkit/stylelint-config
Description: Default stylelint configuration for Mixkit.
Author: Mixkit
Latest version: 1.0.0-alpha.2

# @mixkit/stylelint-config

Default stylelint config used by Mixkit.

<hr>

## Installation

```bash
# NPM
npm install @mixkit/stylelint-config --save-dev

# Yarn
yarn add @mixkit/stylelint-config --save-dev
```

## Usage

Our config covers both CSS and SCSS. Simply extend our config:

```JSON
{
    "extends": "@mixkit/stylelint-config"
}
```
npm package: @mixkit/stylelint-config-mixkit
Description: Default stylelint configuration for Mixkit.
Author: Elias Early-Manchester
Latest version: 1.0.0-alpha.2

# stylelint-config-mixkit

Default stylelint config used by Mixkit.

<hr>

## Installation

```bash
# NPM
npm install stylelint-config-mixkit --save-dev

# Yarn
yarn add stylelint-config-mixkit --save-dev
```

## Usage

Our config covers both CSS and SCSS. Simply extend our config:

```JSON
{
    "extends": "@mixkit/stylelint-config-mixkit"
}
```
npm package: @mixmake/cli
Description: MixMake CLI for MCP happy-path workflows
Latest version: 0.1.5

# MixMake CLI

Official command-line client for MixMake MCP.

It handles MCP initialize/session details for common workflows:
- get API key
- transcribe audio (from URL, existing `audio_id`, or a local `.mp3` / `.wav` / `.m4a` via `transcribe --file`)
- edit transcript deletions
- render output
- run diagnostics

## Quick start

Use `doctor` first, then follow the Commands block below.

## Commands

When passing flags, include `--` after the package name so args go to MixMake CLI (not npm).

```bash
npx -y @mixmake/cli@latest -- doctor
npx -y @mixmake/cli@latest -- doctor --verbose
npx -y @mixmake/cli@latest -- setup --email you@example.com
npx -y @mixmake/cli@latest -- key --email you@example.com
npx -y @mixmake/cli@latest -- transcribe --audio-url https://example.com/file.mp3
npx -y @mixmake/cli@latest -- transcribe --audio-id <audio_id>
npx -y @mixmake/cli@latest -- transcribe --file ./recording.mp3
npx -y @mixmake/cli@latest -- edit --transcript-id <id> --delete id1,id2,id3
npx -y @mixmake/cli@latest -- render --transcript-id <id>
```

## Configuration

Saved at:

`~/.config/mixmake/config.json`

Example:

```json
{
  "endpoint": "https://www.mixmake.com/api/mcp",
  "apiKey": "mmk_..."
}
```

Environment overrides:
- `MIXMAKE_MCP_URL`
- `MIXMAKE_API_KEY`

## Troubleshooting

For diagnostics, run:

```bash
npx -y @mixmake/cli@latest -- doctor --verbose
```

Session notes:
- If a replay-safe command hits `Unknown session` or `Session expired`, CLI re-initializes once and retries automatically.
- CLI intentionally does **not** auto-replay potentially side-effecting commands like `transcribe` and `render` to avoid duplicate jobs.

Local file notes:
- `transcribe --file` uploads via signed URL under the hood, then starts transcription (same MCP `upload_audio` + `transcribe_audio` flow as the server). You need a MixMake **API key**. Run `setup` or `key` first.
- The JSON output includes `transcript_id` and `audio_id`; use **`transcript_id`** with `edit` / `render` once transcription completes (editing does not re-run transcription).
- Max file size **100MB**. Extensions: **.mp3**, **.wav**, **.m4a**.

Setup notes:
- `setup` validates MCP connectivity via `tools/list`, fetches an API key, and saves it to config.
- Use `doctor --verbose` for lightweight request traces (`stage`, status, endpoint, request id).

If you contact support, include:
- request id (if present)
- command you ran
- timestamp and endpoint URL
- contact email: teammixmake@gmail.com

## Development

```bash
cd cli && npm test
```

## Links

- Agent docs: https://mixmake.com/for-agents
- MCP metadata: https://mixmake.com/server.json
npm package: @mixmaxhq/commitlint-jenkins
Description: Lint all relevant commits for a change or PR on Jenkins CI
Author: Mixmax
Latest version: 1.7.0

# commitlint-jenkins

[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)

A wrapper for commitlint that determines the appropriate commit range in a Jenkins build. Adapted
from `@commitlint/travis-cli`.

Only supports `git` projects, assumes a single repository (i.e. does not explicitly support cross-
repo pull requests), and doesn't support renaming the remote to something other than `origin`. We
welcome [pull requests](https://github.com/mixmaxhq/commitlint-jenkins/pulls)!

## Flags

### `--if-ci`

If `commitlint-jenkins` is run outside of a CI context, it will fail. This flag simply ignores the
failure, for use-cases where `commitlint-jenkins` should be run from a script shared with a non-CI
workflow.

### `--pr-only`

If `commitlint-jenkins` is run in CI in a build that isn't a pull request build, silently exit.
This flag is particularly handy for use with
[`@mixmaxhq/semantic-commitlint`](https://github.com/mixmaxhq/semantic-commitlint).

## Publishing a new version

```
GH_TOKEN=xxx npx semantic-release --no-ci
```
npm package: @mixmaxhq/express-robots
Description: Express middleware for generating your robots.txt
Author: ashaffer
Latest version: 1.0.0

# express-robots

Express middleware for generating a robots.txt or responding with an existing file.

## Using a file

```javascript
app.use(robots(__dirname + '/robots.txt'));
```

## Using an object

### Basic object

```javascript
app.use(robots({UserAgent: '*', Disallow: '/'}))
```

#### Will produce:
```
UserAgent: *
Disallow: /
```

### Crawl Delay
You can optionally pass a CrawlDelay in just like passing in Disallow

```javascript
app.use(robots({UserAgent: '*', Disallow: '/', CrawlDelay: '5'}))
```

#### Will produce:
```
UserAgent: *
Disallow: /
Crawl-delay: 5
```

### Or an array of objects

```javascript
app.use(robots([
  {
    UserAgent: 'Googlebot',
    Disallow: '/no-google'
  },
  {
    UserAgent: 'Bingbot',
    Disallow: '/no-bing'
  }
]));
```

#### Will produce:
```
UserAgent: Googlebot
Disallow: /no-google
UserAgent: Bingbot
Disallow: /no-bing
```

### Or either property (UserAgent | Disallow) as an array

```javascript
app.use(robots([
  {
    UserAgent: [ 'Googlebot', 'Slurp' ],
    Disallow: [ '/no-google', '/no-yahoo' ]
  },
  {
    UserAgent: '*',
    Disallow: [ '/no-bots', '/still-no-bots' ]
  }
]));
```

#### Will produce:
```
UserAgent: Googlebot
UserAgent: Slurp
Disallow: /no-google
Disallow: /no-yahoo
UserAgent: *
Disallow: /no-bots
Disallow: /still-no-bots
```
npm package: @mixmaxhq/invoke-fraction
Description: Partition invocations across a set of functions based on defined fractions.
Author: Eli Skeggs
Latest version: 2.0.0

invoke-fraction
===============

Partition invocations across a set of functions based on defined fractions.

### Example

```js
// Randomly invoke one of following arrow functions based on the given fraction.
// e.g. it'll invoke the first function ~10% of the time if called repeatedly.
invokeFraction([
  [0.1, () => console.log('10%')],
  [0.3, () => console.log('30%')],
  // The number here doesn't matter, provided it's >0, as it's the last partition.
  [0.6, () => console.log('60%')],
]);
```

The `invokeFraction` function also supports a `defaultHandler` parameter, which stands in for the
last item of the handlers array. Note that this is the recommended way to avoid letting the last
item in the handlers array be invoked for the remaining partition, rather than the defined fraction.

```js
invokeFraction([
  [0.1, () => console.log('10%')],
  [0.3, () => console.log('30%')],
], () => console.log('60%'));
```

The `invokeFraction` function will return the value returned by the function invoked, so you can use
this with promises and async/await.
npm package: @mixmaxhq/nivo-bar
Description: [![version](https://img.shields.io/npm/v/@nivo/bar.svg?style=flat-square)](https://www.npmjs.com/package/@nivo/bar)
Author: Raphaël Benitte
Latest version: 0.62.1

# `@nivo/bar`

[![version](https://img.shields.io/npm/v/@nivo/bar.svg?style=flat-square)](https://www.npmjs.com/package/@nivo/bar)

## Bar

[documentation](http://nivo.rocks/bar)

![Bar](https://raw.githubusercontent.com/plouc/nivo/master/packages/bar/doc/bar.png)

## BarCanvas

[documentation](http://nivo.rocks/bar/canvas)

![BarCanvas](https://raw.githubusercontent.com/plouc/nivo/master/packages/bar/doc/bar-canvas.png)
npm package: @mixmaxhq/post-github-comment-from-travis
Description: Post an automated message to the relevant GitHub pull request.
Author: Eli Skeggs
Latest version: 0.1.1

# post-github-comment-from-travis

Post a comment to the appropriate pull request thread on GitHub when run in a pull request build on
GitHub.

Beware: this package will attach an `asyncIterator` property to `Symbol` if one does not exist, for
compatibility reasons. If you find this problematic, feel free to submit a pull request.

Should support Node 7.6+ (uses untranspiled `async` and `await`).

## Install

```sh
$ npm i -D '@mixmaxhq/post-github-comment-from-travis'
```

## Usage

```js
import { postComment } from '@mixmaxhq/post-github-comment-from-travis';
import pkg from './package.json';

const numDependencies = Object.keys(pkg.dependencies).length;
postComment(`there are now ${numDependencies} dependencies`, { purpose: 'dependency-count' }).then(
  (result) => console.log(result)
);
```

```sh
$ post-github-comment-from-travis --purpose package-tree-size
  <<< "there are now $(wc -l package-lock.json) lines in the lockfile"
```

## API

### `postComment(content, { ?auth, ?purpose, ?replace })`

Post a comment to the contextually relevant GitHub pull request.

- `content`: the GitHub-flavored markdown content to put in the comment
- `auth`: the optional authentication parameter to pass to `@octokit/rest` - will use the `GITHUB_TOKEN` environment variable if not provided
- `purpose`: a string signifying the comment's purpose - repeated calls with the same purpose on the same pull request will overwrite the prior comment
- `replace`: if `true` (and a `purpose` is provided), create a new comment and delete the old one instead of editing it. if `replace` is `force`, recreates the comment even if the content hasn't changed.

By default, will not edit/replace the comment if the `content` is the same as the existing comment.
npm package: @mixmaxhq/sdk
Description: Our client-side SDK.
Author: Mixmax
Latest version: 2.0.7

# Mixmax JS SDK

[![Build Status](https://travis-ci.org/mixmaxhq/mixmax-sdk-js.svg?branch=master)](https://travis-ci.org/mixmaxhq/mixmax-sdk-js)

This repo is for our Mixmax JavaScript SDK for use by third party apps as well as Mixmax's own apps.
It exports a top level module called `Mixmax`, with submodules

* `Mixmax.editor`: APIs for managing the lifecycle of a [Mixmax enhancement]'s editor as documented
[here][Mixmax.editor docs].
* `Mixmax.widgets`: APIs for embedding Mixmax functionality in your own website, currently the
sequence picker as documented [here][sequence picker docs] and the embedded calendar as documented
[here][embedded cal docs].
* `Mixmax.sidebar`: APIs for integrating your website into the Mixmax sidebar as documented
[here][Mixmax.sidebar docs].

If you are interested in contributing to this repo, see [here][CONTRIBUTING.md].

[Mixmax enhancement]: https://developer.mixmax.com/docs/overview-enhancement
[Mixmax.editor docs]: https://developer.mixmax.com/docs/overview-enhancement#sdkjs
[sequence picker docs]: https://developer.mixmax.com/docs/sequences-picker
[embedded cal docs]: https://developer.mixmax.com/docs/embedded-calendar
[Mixmax.sidebar docs]: https://developer.mixmax.com/docs/sidebars
[CONTRIBUTING.md]: CONTRIBUTING.md
npm package: @mixmaxhq/semantic-commitlint
Description: Fills the gap between semantic-release and commitlint
Author: Eli Skeggs
Latest version: 1.0.3

# Semantic Commitlint

📦🚀 + 📓 A continuous integration build tool to ensure all new commits meet your commit message format!

## Problem

* [📦🚀 semantic-release](https://github.com/semantic-release/semantic-release) depends on properly
  formatted commit messages
* [📓 commitlint](https://github.com/marionebl/commitlint) is awesome, but it doesn't know which
  commits occurred since your last release

## Solution

* [semantic-commitlint](https://github.com/adriancarriger/semantic-commitlint) fills the gap by
  providing a hook for `semantic-release` that asks `commitlint` to lint new commit messages that
  have not been included in a previous release

## Features

* Run in CI on all branches to ensure that only builds with valid commit messages pass
* Wraps [`semantic-release`](https://github.com/semantic-release/semantic-release) and
  [`commitlint`](https://github.com/marionebl/commitlint) for an easy install
* No config

## Install

```bash
npm install semantic-commitlint --save-dev
```

## Setup

Add the following to your `semantic-release` release block (e.g. in the `release` field of your
`package.json`)

```json
{
  "verifyRelease": ["semantic-commitlint"]
}
```

Setup [semantic-release authentication](https://github.com/semantic-release/semantic-release/blob/caribou/docs/usage/ci-configuration.md#ci-configuration) for CI

`semantic-commitlint` currently only supports `@commitlint/config-conventional` - please open a PR
if you need support for other configurations!

## Usage

Simply run `semantic-release` as normal as part of your CI build process

## Skip commits

If there are unreleased commits that shouldn't fail a build, then add them to the
`SEMANTIC_COMMITLINT_SKIP` environment variable as comma-separated GIT SHAs. This should be
uncommon, provided your development workflow lints the commits before they get added to the release
branch.

```jsonc
// This is the package.json of the package you're trying to publish.
// Just add the SEMANTIC_COMMITLINT_SKIP prefix to the semantic-release command!
{
  "scripts": {
    "semantic-release": "SEMANTIC_COMMITLINT_SKIP=a1be371 semantic-release"
  }
}
```

## External config

This project just ties together some functionality from two external projects. For all other config
options make sure to read through the docs.

* [📦🚀 semantic-release](https://github.com/semantic-release/semantic-release)
* [📓 commitlint](https://github.com/marionebl/commitlint)

## Issues

Not all features implemented in `semantic-release` and `commitlint` are currently available when
using `semantic-commtlint`. If you have a suggestion, please
[open an issue](https://github.com/mixmaxhq/semantic-commitlint/issues/new). Thanks!

## License

semantic-commitlint is licensed under the MIT Open Source license.
For more information, see the [LICENSE] file in this repository.

[LICENSE]: https://github.com/mixmaxhq/semantic-commitlint/blob/master/LICENSE
npm package: @mixmaxhq/semantic-release-config
Description: The shared configuration we use for `semantic-release`.
Author: Eli Skeggs
Latest version: 4.0.0

# @mixmaxhq/semantic-release-config

The shared configuration we use for `semantic-release`.

At Mixmax, we support the commit types listed [here][commit-types].

[commit-types]: https://github.com/commitizen/conventional-commit-types/blob/master/index.json

## Publishing a new version

```
GH_TOKEN=xxx npx semantic-release --no-ci
```
npm package: @mixmaxhq/storybook-addon-contributors
Description: Contributors information addon for storybook.js
Author: Andy Tran
Latest version: 1.0.1

# storybook-addon-contributors
Storybook Addon Contributors allow you to view the contributors information using the Storybook UI.

This is how Contributors look like:
![](docs/screenshot.png)

## Getting started
First, install the addon.
```
$ npm add @mixmaxhq/storybook-addon-contributors --dev
```

Add this line to your addons.js file (create this file inside your storybook config directory if needed).
```javascript
import '@mixmaxhq/storybook-addon-contributors/register';
```

Import the withContributors decorator to check your stories for contributors information.
```javascript
import { withContributors } from '@mixmaxhq/storybook-addon-contributors';

// should only be added once
// best place is in config.js
addDecorator(withContributors)
```

Here is an example of using Contributors with a React component.
```javascript
Button.contributors = [
  {
    name: 'Andy Tran',
    url: 'https://github.com/andyhqtran',
  },
];
```
npm package: @mixmaxhq/tail
Description: tail a file in node
Author: Luca Grulla
Latest version: 1.3.0

# Tail

[![NPM](https://nodei.co/npm/tail.png?downloads=true&downloadRank=true)](https://nodei.co/npm/tail.png?downloads=true&downloadRank=true)

Author: Luca Grulla - [www.lucagrulla.com](https://www.lucagrulla.com)

# Installation

```bash
npm install tail
```

# Use:
```javascript
Tail = require('tail').Tail;

tail = new Tail("fileToTail");

tail.on("line", function(data) {
  console.log(data);
});

tail.on("error", function(error) {
  console.log('ERROR: ', error);
});
```

If you want to stop tail:

```javascript
tail.unwatch()
```

To start watching again:
```javascript
tail.watch()
```

# Configuration
The only mandatory parameter is the path to the file to tail. 

```javascript
var fileToTail = "/path/to/fileToTail.txt";
new Tail(fileToTail)
```

Optional parameters can be passed via a hash:

```javascript
var options= {separator: /[\r]{0,1}\n/, fromBeginning: false, startPos: 50, fsWatchOptions: {}, follow: true, logger: console}
new Tail(fileToTail, options)
```

# Available parameters:

* `separator`:  the line separator token (default `/[\r]{0,1}\n/` to handle linux/mac (9+)/windows)
* `fsWatchOptions`:  the full set of options that can be passed to `fs.watch` as per node documentation (default: {})
* `fromBeginning`: forces the tail of the file from the very beginning of it instead of from the first new line that will be appended (default: `false`)
* `startPos`: forces the tail from certain position, if set — `fromBeginning` param will be ignored. (default: `null`)
* `follow`: simulate `tail -F` option. In the case the file is moved/renamed (or logrotated), if set to `true` `tail` will try to start tailing again after a 1 second delay, if set to `false` it will just emit an error event (default: `true`)
* `logger`: a logger object(default: no logger). The passed logger has to respond to two methods:
    * `info([data][, ...])`
    * `error([data][, ...])`
* `useWatchFile`: if set to `true` will force the use of `fs.watchFile` rather than delegating to the library the choice between `fs.watch` and `fs.watchFile` (default: `false`)
* `encoding`: the encoding of the file to tail (default:`utf-8`)

# Emitted events
`Tail` emits four events:

* line
```
function(data){
  console.log(data)
}
```
* data
```
function(data){
  console.log(data)
}
```
* error
```
function(exception){}
```
* historicalDataEnd
```
function(end){
  console.log('Historical data size is', end)
}
```

# Want to fork?

Tail is written in [CoffeeScript](http://jashkenas.github.com/coffee-script/).

The Cakefile generates the javascript that is then published to npm.

# Real world use

Tail was born as part of a data firehose. Read about it [here](https://www.lucagrulla.com/posts/building-a-firehose-with-nodejs/).

# License
MIT. Please see License file for more details.
npm package: @mixmaxhq/travis-utils
Description: Interact with the corresponding GitHub pull request from Travis.
Author: Eli Skeggs
Latest version: 0.1.0

# travis-utils

A quick module that exports some utilities for interacting with GitHub PRs from Travis.

## Install

```sh
$ npm i -D '@mixmaxhq/travis-utils'
```

## Usage

```js
import { getClient, getOptions } from '@mixmaxhq/travis-utils';

const client = getClient();

await client.issues.createComment(
  getOptions({
    body: "I'm in ur base writing a comment",
  })
);
```
npm package: @mixmaxhq/url-id
Description: Encode and parse tiny, url-safe objects of identifiers
Author: Eli Skeggs
Latest version: 0.1.3

url-id
======

A utility for encoding and parsing tiny, url-safe objects of identifiers

Install
-------

```sh
$ npm install @mixmaxhq/url-id
```

Usage
-----

Create an `Encoder` instance, define encoding/decoding rules on it, and begin encoding objects.

```js
const Encoder = require('url-id');

// The default context to encode/decode in.
const encoder = new Encoder('main');

encoder.define('main', {
  token: 'g',
  match: (obj) => obj && obj.type === 'gmailMessageId',
  encode(obj) {
    this.assert(typeof obj.userId === 'string');
    return this.encode('id', obj.userId) + this.encode('id', obj.gmailMessageId);
  },
  decode() {
    const data = {
      type: 'gmailMessageId'
    };

    [data.userId, data.gmailMessageId] = this.decode('id', 2);
    return data;
  }
});

encoder.define('id', {
  token: 'z',
  encode(input) {
    return this.string(input, 'utf8');
  },
  decode() {
    return this.string('utf8');
  }
});

const exampleData = {
  type: 'gmailMessageId',
  userId: '76456789976',
  gmailMessageId: 'some id here (full unicode)'
};

encoder.encode(exampleData);
// => gzALNzY0NTY3ODk5NzYzAbc29tZSBpZCBoZXJlIChmdWxsIHVuaWNvZGUp
//    (length: 58)

encoder.decode('gzALNzY0NTY3ODk5NzYzAbc29tZSBpZCBoZXJlIChmdWxsIHVuaWNvZGUp');
// => { type: 'gmailMessageId',
//      userId: '76456789976',
//      gmailMessageId: 'some id here (full unicode)' }

// compare to just base64-encoding JSON.stringify:
Buffer.from(JSON.stringify(exampleData)).toString('base64');
// eyJ0eXBlIjoiZ21haWxNZXNzYWdlSWQiLCJ1c2VySWQiOiI3NjQ1Njc4OTk3NiIsImdtYWlsTWVzc2FnZUlkIjoic29tZSBpZCBoZXJlIChmdWxsIHVuaWNvZGUpIn0=
// (length: 128)
```

License
-------

[The MIT License](https://github.com/mixmaxhq/url-id/blob/master/LICENSE)
npm package: @mixnjuice/sequelize-mock
Description: A simple mock interface specifically for testing code relying on Sequelize models
Author: Blink UX
Latest version: 0.11.1

# Sequelize Mock
[![npm](https://img.shields.io/npm/v/sequelize-mock.svg)](https://www.npmjs.com/package/sequelize-mock) [![CircleCI](https://img.shields.io/circleci/project/BlinkUX/sequelize-mock.svg)](https://circleci.com/gh/BlinkUX/sequelize-mock) [![Coveralls](https://img.shields.io/coveralls/BlinkUX/sequelize-mock.svg)](https://coveralls.io/github/BlinkUX/sequelize-mock) [![MIT License](https://img.shields.io/github/license/BlinkUX/sequelize-mock.svg)](https://github.com/BlinkUX/sequelize-mock) [![Documentation Status](https://readthedocs.org/projects/sequelize-mock/badge/?version=stable)](http://sequelize-mock.readthedocs.io/en/stable/?badge=stable)

A mocking interface designed for testing code that uses [Sequelize](http://sequelizejs.com).

Documentation at [sequelize-mock.readthedocs.io](https://sequelize-mock.readthedocs.io/)

## Install

```
npm i sequelize-mock --save-dev
```

## Getting Started

The Mock Models created with this library function as drop in replacements for your unit testing.

Start by importing the library

```javascript
var SequelizeMock = require('sequelize-mock');
```

Initialize the library as you would Sequelize

```javascript
var DBConnectionMock = new SequelizeMock();
```

Define your models

```javascript
var UserMock = DBConnectionMock.define('users', {
		'email': 'email@example.com',
		'username': 'blink',
		'picture': 'user-picture.jpg',
	}, {
		instanceMethods: {
			myTestFunc: function () {
				return 'Test User';
			},
		},
	});
```

Once Mock models have been defined, you can use them as drop-in replacements for your Sequelize model objects. Data is not retrieved from a database and instead is returned based on the setup of the mock objects, the query being made, and other applied or included information.

For example, your code might look something like this

```javascript
UserMock.findOne({
	where: {
		username: 'my-user',
	},
}).then(function (user) {
	// `user` is a Sequelize Model-like object
	user.get('id');         // Auto-Incrementing ID available on all Models
	user.get('email');      // 'email@example.com'; Pulled from default values
	user.get('username');   // 'my-user'; Pulled from the `where` in the query
	
	user.myTestFunc();      // Will return 'Test User' as defined above
});
```

## Contributing

This library is under active development, so you should feel free to submit issues, questions, or pull requests.

## License

Created by Blink UX and licensed under the MIT license. Check the LICENSE file for more information.
npm package: @mixon00/cov19
Description: COVID-19 CLI Tool
Author: Mateusz Misztoft
Latest version: 1.0.0

<p align="center">
 <img src="https://repository-images.githubusercontent.com/272448130/983ae580-b23c-11ea-874a-e8ce6fc2d7f5">
</p>

[![npm](https://img.shields.io/npm/v/@mixon00/cov19.svg)][npm-link]
[![license](https://img.shields.io/github/license/mixon00/cov19-cli.svg)][mit-license]
[![npm](https://img.shields.io/npm/dm/@mixon00/cov19.svg)][npm-link]
[![ko-fi](https://img.shields.io/badge/Buy_me_a-coffee-F16061.svg)][kofi-donation]
![github](https://img.shields.io/github/stars/mixon00/cov19-cli.svg?style=social)
[![twitter](https://img.shields.io/twitter/follow/mixon00.svg?&style=social)][twitter-url]

## Installation

```sh
$ npm i -g @mixon00/cov19
```

## Usage

### Get stats for world and favourites countries

```sh
$ cov19
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593015600432.gif">
</p>

### Get stats for country by country name

```sh
$ cov19 Poland
```

### or country code

```sh
$ cov19 pl
```

### or state

```sh
$ cov19 "New York"
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593015314848.gif">
</p>

### Show detailed stats

```sh
$ cov19 -s
```

or

```sh
$ cov19 Poland -s
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593016893891.gif">
</p>

### Add to favourites

```sh
$ cov19 Poland -a
```

or

```sh
$ cov19 Poland --add
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593014914515.gif">
</p>

### Remove from favourites

```sh
$ cov19 Poland -r
```

or

```sh
$ cov19 Poland --remove
```

### Remove more then one element from favourites

```sh
$ cov19 -r
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593016145609.gif">
</p>

### Limit displayed results

```sh
$ cov19 us -l <limit>
$ cov19 us -l 3
```

### or limit displayed result starting from selected position

```sh
$ cov19 us -l <from:limit>
$ cov19 us -l 2:5
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593017962811.gif">
</p>

### Display list of favourites

```sh
$ cov19 -f
```

or

```sh
$ cov19 --favourites
```

<p align="center">
 <img src="https://raw.githubusercontent.com/mixon00/cov19-cli/master/docs/render1593016045911.gif">
</p>

### Show about tool

```sh
$ cov19 --about
```


## Prerequisites

Before running this locally you must have these installed

- [Node](https://nodejs.org/)
- [npm](https://www.npmjs.com/)

## Contributing

1. 🍴 Fork repo!
2. 🌈🌈🌈 **_DO MAGIC!_** 🌈🌈🌈
3. 🔃 Create a new pull request.

Feel free to contribute to this project. 😊

## License

Code copyright 2020 Mateusz Misztoft. Code released under [MIT License][mit-license]

[mit-license]: https://github.com/mixon00/cov19-cli/blob/master/LICENSE
[npm-link]: https://www.npmjs.com/package/@mixon00/cov19
[twitter-url]: https://twitter.com/mixon00
[kofi-donation]: https://ko-fi.com/Y8Y6NZPR
npm package: @mixoo-ui/table
Description: Styles and components for use in svelte websites
Latest version: 1.0.0

# create-svelte

Everything you need to build a Svelte library, powered by [`create-svelte`](https://github.com/sveltejs/kit/tree/main/packages/create-svelte).

Read more about creating a library [in the docs](https://kit.svelte.dev/docs/packaging).

## Creating a project

If you're seeing this, you've probably already done this step. Congrats!

```bash
# create a new project in the current directory
npm create svelte@latest

# create a new project in my-app
npm create svelte@latest my-app
```

## Developing

Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:

```bash
npm run dev

# or start the server and open the app in a new browser tab
npm run dev -- --open
```

Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.

## Building

To build your library:

```bash
npm run package
```

To create a production version of your showcase app:

```bash
npm run build
```

You can preview the production build with `npm run preview`.

> To deploy your app, you may need to install an [adapter](https://kit.svelte.dev/docs/adapters) for your target environment.

## Publishing

Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).

To publish your library to [npm](https://www.npmjs.com):

```bash
npm publish
```
npm package: @mixpanel/dnd-kit-react
Description: [![Stable release](https://img.shields.io/npm/v/@mixpanel/dnd-kit-react.svg)](https://npm.im/@mixpanel/dnd-kit-react)
Latest version: 0.1.21-v1

# @mixpanel/dnd-kit-react

[![Stable release](https://img.shields.io/npm/v/@mixpanel/dnd-kit-react.svg)](https://npm.im/@mixpanel/dnd-kit-react)

The React layer for @dnd-kit, built on top of @dnd-kit/dom.

## Installation

To get started, install the `@mixpanel/dnd-kit-react` package via npm or yarn:

```
npm install @mixpanel/dnd-kit-react
```

## Usage

Visit [docs.dndkit.com](https://docs.dndkit.com) to learn how to get started with @dnd-kit.
npm package: @mixpanel/rrweb-plugin-canvas-webrtc-record
Description: Plugin that live streams contents of canvas elements via webrtc
Author: justin@recordonce.com
Latest version: 2.0.0-alpha.18.4

# rrweb canvas webrtc plugin

Plugin that live streams contents of canvas elements via webrtc

## Example of live streaming via `yarn live-stream`

https://user-images.githubusercontent.com/4106/186701616-fd71a107-5d53-423c-ba09-0395a3a0252f.mov

## Instructions

### Record side

```js
// Record side

import rrweb from 'rrweb';
import { RRWebPluginCanvasWebRTCRecord } from 'rrweb-plugin-canvas-webrtc-record';

const webRTCRecordPlugin = new RRWebPluginCanvasWebRTCRecord({
  signalSendCallback: (msg) => {
    // provides webrtc sdp offer signal & connect message
    // make sure you send this to the replayer's `webRTCReplayPlugin.signalReceive(signal)`
    sendSignalToReplayer(msg); // example of function that sends the signal to the replayer
  },
});

rrweb.record({
  emit: (event) => {
    // send these events to the `replayer.addEvent(event)`, how you do that is up to you
    // you can send them to a server for example which can then send them to the replayer
    sendEventToReplayer(event); // example of function that sends the event to the replayer
  },
  plugins: [
    // add the plugin to the list of plugins, and initialize it via `.initPlugin()`
    webRTCRecordPlugin.initPlugin(),
  ],
  recordCanvas: false, // we don't want canvas recording turned on, we're going to do that via the plugin
});
```

### Replay Side

```js
// Replay side
import rrweb from 'rrweb';
import { RRWebPluginCanvasWebRTCReplay } from 'rrweb-plugin-canvas-webrtc-replay';

const webRTCReplayPlugin = new RRWebPluginCanvasWebRTCReplay({
  canvasFoundCallback(canvas, context) {
    console.log('canvas', canvas);
    // send the canvas id to `webRTCRecordPlugin.setupStream(id)`, how you do that is up to you
    // you can send them to a server for example which can then send them to the replayer
    sendCanvasIdToRecordScript(context.id); // example of function that sends the id to the record script
  },
  signalSendCallback(signal) {
    // provides webrtc sdp offer signal & connect message
    // make sure you send this to the record script's `webRTCRecordPlugin.signalReceive(signal)`
    sendSignalToRecordScript(signal); // example of function that sends the signal to the record script
  },
});

const replayer = new rrweb.Replayer([], {
  UNSAFE_replayCanvas: true, // turn canvas replay on!
  liveMode: true, // live mode is needed to stream events to the replayer
  plugins: [webRTCReplayPlugin.initPlugin()],
});
replayer.startLive(); // start the replayer in live mode

replayer.addEvent(event); // call this whenever an event is received from the record script
```

## More info

https://github.com/rrweb-io/rrweb/pull/976
npm package: @mixpeal/string-to-elements
Description: Converts string to html elements
Author: Kayode Ojo
Latest version: 1.0.2

It convert strings to html elements, by breaking the sentence down into words and wrapping them with <span> element


## Installation

```bash
# install dependencies
$ npm i @mixpeal/string-to-elements
```
Then import import it like this:

## Usage
```bash
import { elementUp } from "@mixpeal/string-to-elements";

elementUp('A demo string');

#ouput
<span>A</span> <span>demo</span> <span>string</span>
```
npm package: @mixpeek/airflow
Description: Apache Airflow integration for Mixpeek — custom operators, DAG generators, and task builders
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/airflow

Apache Airflow integration for Mixpeek — custom operators, DAG generators, and task builders

## Installation

```bash
npm install @mixpeek/airflow
```

## Quick Start

```js
import mixpeekOperator from '@mixpeek/airflow';

const instance = mixpeekOperator({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### MixpeekOperator

Airflow operator that executes Mixpeek enrichment tasks within DAGs

```js
import { createMixpeekOperator } from '@mixpeek/airflow';

const mixpeekOperator = createMixpeekOperator({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### DagGenerator

Generates Airflow DAG definitions for Mixpeek enrichment pipelines

```js
import { createDagGenerator } from '@mixpeek/airflow';

const dagGenerator = createDagGenerator({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### TaskBuilder

Fluent builder for creating Mixpeek enrichment tasks within Airflow DAGs

```js
import { createTaskBuilder } from '@mixpeek/airflow';

const taskBuilder = createTaskBuilder({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/anthropic
Description: Anthropic integration for Mixpeek — tool definitions, content adapters, and MCP server for Claude
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/anthropic

Anthropic integration for Mixpeek — tool definitions, content adapters, and MCP server for Claude

## Installation

```bash
npm install @mixpeek/anthropic @anthropic-ai/sdk
```

## Quick Start

```js
import toolDefinitions from '@mixpeek/anthropic';

const instance = toolDefinitions({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### ToolDefinitions

Provides Mixpeek search/enrichment as Claude tool_use definitions

```js
import { createToolDefinitions } from '@mixpeek/anthropic';

const toolDefinitions = createToolDefinitions({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### ContentAdapter

Adapts Mixpeek multimodal content for Claude message format (text, images, documents)

```js
import { createContentAdapter } from '@mixpeek/anthropic';

const contentAdapter = createContentAdapter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### McpServer

Model Context Protocol server exposing Mixpeek as MCP tools and resources

```js
import { createMcpServer } from '@mixpeek/anthropic';

const mcpServer = createMcpServer({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/aws-lambda
Description: AWS Lambda integration for Mixpeek — handler wrappers, event routing, and response formatting for serverless enrichment
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/aws-lambda

AWS Lambda integration for Mixpeek — handler wrappers, event routing, and response formatting for serverless enrichment

## Installation

```bash
npm install @mixpeek/aws-lambda
```

## Quick Start

```js
import lambdaHandler from '@mixpeek/aws-lambda';

const instance = lambdaHandler({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### LambdaHandler

Wraps Mixpeek enrichment in an AWS Lambda handler with cold start optimization

```js
import { createLambdaHandler } from '@mixpeek/aws-lambda';

const lambdaHandler = createLambdaHandler({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### EventRouter

Routes Lambda events (API Gateway, S3, SQS, EventBridge) to appropriate Mixpeek operations

```js
import { createEventRouter } from '@mixpeek/aws-lambda';

const eventRouter = createEventRouter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### ResponseFormatter

Formats Mixpeek enrichment results into Lambda-compatible response objects

```js
import { createResponseFormatter } from '@mixpeek/aws-lambda';

const responseFormatter = createResponseFormatter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/aws-s3
Description: AWS S3 integration for Mixpeek — watch buckets for new objects, enrich content, and parse S3 events
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/aws-s3

AWS S3 integration for Mixpeek — watch buckets for new objects, enrich content, and parse S3 events

## Installation

```bash
npm install @mixpeek/aws-s3 @aws-sdk/client-s3
```

## Quick Start

```js
import s3Watcher from '@mixpeek/aws-s3';

const instance = s3Watcher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### S3Watcher

Watches S3 buckets for new/modified objects and triggers Mixpeek enrichment

```js
import { createS3Watcher } from '@mixpeek/aws-s3';

const s3Watcher = createS3Watcher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### S3Enricher

Enriches S3 objects through Mixpeek and stores results back in S3 or metadata

```js
import { createS3Enricher } from '@mixpeek/aws-s3';

const s3Enricher = createS3Enricher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### S3EventParser

Parses S3 event notifications (SNS/SQS/EventBridge) into normalized objects

```js
import { createS3EventParser } from '@mixpeek/aws-s3';

const s3EventParser = createS3EventParser({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/azure-blob
Description: Azure Blob Storage integration for Mixpeek — watch containers, enrich blobs, and parse Event Grid events
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/azure-blob

Azure Blob Storage integration for Mixpeek — watch containers, enrich blobs, and parse Event Grid events

## Installation

```bash
npm install @mixpeek/azure-blob @azure/storage-blob
```

## Quick Start

```js
import blobWatcher from '@mixpeek/azure-blob';

const instance = blobWatcher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### BlobWatcher

Watches Azure Blob containers for new/modified blobs via Event Grid subscriptions

```js
import { createBlobWatcher } from '@mixpeek/azure-blob';

const blobWatcher = createBlobWatcher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### BlobEnricher

Enriches Azure Blobs through Mixpeek and stores enrichment metadata

```js
import { createBlobEnricher } from '@mixpeek/azure-blob';

const blobEnricher = createBlobEnricher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### EventGridParser

Parses Azure Event Grid events into normalized blob event objects

```js
import { createEventGridParser } from '@mixpeek/azure-blob';

const eventGridParser = createEventGridParser({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/contentful
Description: Contentful integration for Mixpeek — webhook handling, content enrichment, and management API integration
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/contentful

Contentful integration for Mixpeek — webhook handling, content enrichment, and management API integration

## Installation

```bash
npm install @mixpeek/contentful contentful-management
```

## Quick Start

```js
import webhookHandler from '@mixpeek/contentful';

const instance = webhookHandler({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### WebhookHandler

Handles Contentful webhooks (entry publish/unpublish/archive) and triggers enrichment

```js
import { createWebhookHandler } from '@mixpeek/contentful';

const webhookHandler = createWebhookHandler({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### ContentEnricher

Enriches Contentful entries with Mixpeek multimodal analysis stored in custom fields

```js
import { createContentEnricher } from '@mixpeek/contentful';

const contentEnricher = createContentEnricher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### ContentfulClient

Contentful Management API client for reading/writing enrichment data

```js
import { createContentfulClient } from '@mixpeek/contentful';

const contentfulClient = createContentfulClient({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/databricks
Description: Databricks integration for Mixpeek — notebook helpers, Delta Lake integration, and Unity Catalog connector
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/databricks

Databricks integration for Mixpeek — notebook helpers, Delta Lake integration, and Unity Catalog connector

## Installation

```bash
npm install @mixpeek/databricks @databricks/sql
```

## Quick Start

```js
import notebookHelper from '@mixpeek/databricks';

const instance = notebookHelper({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### NotebookHelper

Helper functions for using Mixpeek enrichment within Databricks notebooks

```js
import { createNotebookHelper } from '@mixpeek/databricks';

const notebookHelper = createNotebookHelper({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### DeltaLakeIntegration

Reads from and writes enrichment results to Delta Lake tables

```js
import { createDeltaLakeIntegration } from '@mixpeek/databricks';

const deltaLakeIntegration = createDeltaLakeIntegration({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### UnityConnector

Unity Catalog integration for registering Mixpeek as an external data source

```js
import { createUnityConnector } from '@mixpeek/databricks';

const unityConnector = createUnityConnector({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/datadog
Description: Datadog integration for Mixpeek — metrics, logs, and distributed tracing for enrichment pipelines
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/datadog

Datadog integration for Mixpeek — metrics, logs, and distributed tracing for enrichment pipelines

## Installation

```bash
npm install @mixpeek/datadog dd-trace
```

## Quick Start

```js
import metricsReporter from '@mixpeek/datadog';

const instance = metricsReporter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### MetricsReporter

Reports Mixpeek enrichment metrics to Datadog (counters, gauges, distributions)

```js
import { createMetricsReporter } from '@mixpeek/datadog';

const metricsReporter = createMetricsReporter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### LogForwarder

Forwards Mixpeek enrichment logs to Datadog Logs with structured metadata

```js
import { createLogForwarder } from '@mixpeek/datadog';

const logForwarder = createLogForwarder({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### TraceIntegration

Integrates Mixpeek enrichment spans into Datadog APM traces

```js
import { createTraceIntegration } from '@mixpeek/datadog';

const traceIntegration = createTraceIntegration({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/gcp-functions
Description: Google Cloud Functions integration for Mixpeek — handler wrappers, event routing, and response formatting
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/gcp-functions

Google Cloud Functions integration for Mixpeek — handler wrappers, event routing, and response formatting

## Installation

```bash
npm install @mixpeek/gcp-functions
```

## Quick Start

```js
import functionHandler from '@mixpeek/gcp-functions';

const instance = functionHandler({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### FunctionHandler

Wraps Mixpeek enrichment in a Cloud Functions handler with cold start optimization

```js
import { createFunctionHandler } from '@mixpeek/gcp-functions';

const functionHandler = createFunctionHandler({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### EventRouter

Routes Cloud Function events (HTTP, Pub/Sub, GCS, Firestore) to Mixpeek operations

```js
import { createEventRouter } from '@mixpeek/gcp-functions';

const eventRouter = createEventRouter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### ResponseFormatter

Formats Mixpeek enrichment results into Cloud Functions response objects

```js
import { createResponseFormatter } from '@mixpeek/gcp-functions';

const responseFormatter = createResponseFormatter({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT
npm package: @mixpeek/gcs
Description: Google Cloud Storage integration for Mixpeek — watch buckets, enrich objects, and parse GCS events
Author: Mixpeek
Latest version: 1.0.0

# @mixpeek/gcs

Google Cloud Storage integration for Mixpeek — watch buckets, enrich objects, and parse GCS events

## Installation

```bash
npm install @mixpeek/gcs @google-cloud/storage
```

## Quick Start

```js
import gCSWatcher from '@mixpeek/gcs';

const instance = gCSWatcher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Modules

### GCSWatcher

Watches GCS buckets for new/modified objects via Pub/Sub notifications

```js
import { createGCSWatcher } from '@mixpeek/gcs';

const gCSWatcher = createGCSWatcher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### GCSEnricher

Enriches GCS objects through Mixpeek and stores enrichment results

```js
import { createGCSEnricher } from '@mixpeek/gcs';

const gCSEnricher = createGCSEnricher({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

### GCSEventParser

Parses GCS event notifications (Pub/Sub, Eventarc) into normalized objects

```js
import { createGCSEventParser } from '@mixpeek/gcs';

const gCSEventParser = createGCSEventParser({
  apiKey: process.env.MIXPEEK_API_KEY
});
```

## Testing

```bash
npm test              # Unit tests
npm run test:e2e      # End-to-end tests
npm run test:live     # Live API tests (requires MIXPEEK_API_KEY)
npm run test:coverage # Coverage report
```

## License

MIT