open-index/open-npm huggingface dataset:
npm package: @smhg/date-interval
Description: Algebraic operations for time intervals
Author: Sam Hauglustaine
Latest version: 1.3.0

date-interval  [![Build status](https://api.travis-ci.org/smhg/date-interval-js.png)](https://travis-ci.org/smhg/date-interval-js)
======
Algebraic operations for time intervals.

## Installation
```bash
$ npm install @smhg/date-interval
```

## Usage
```javascript
import Interval from '@smhg/date-interval';

// with ISO 8601 string
let interval1 = Interval('2015-08-03T12:00:00Z/2015-08-04T12:00:00Z');

// with 2 dates
let interval2 = Interval(new Date('2015-08-03T12:00:00Z'), new Date('2015-08-04T12:00:00Z'));
```

## API
### Interval()
#### Interval(String)
Pass an ISO 8601 time interval formatted string to create an interval.

#### Interval(Date, Date)
Pass a start and end Date object to create an interval.

### interval.toString()
Returns the interval as an ISO 8601 formatted string.

### interval.overlaps(Interval)
Returns whether both intervals overlap.

### interval.union(Interval)
Returns an array with the result of a merge of both intervals.

### interval.diff(Interval)
Returns an array with the difference of both intervals.

### interval.intersection(Interval)
Returns the interval that lies at the intersection of both intervals (if any).
npm package: @smhg/date-time-zone
Description: Create and manipulate time zone specific dates as regular Date objects.
Latest version: 1.1.1

date-time-zone [![Build status](https://api.travis-ci.org/smhg/date-time-zone.png)](https://travis-ci.org/smhg/date-time-zone)
======

Create and manipulate time zone specific dates as regular Date objects.
(~Abuses~)Uses [Intl](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl) and [Proxy](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy).

## Example
```javascript
const { createDate, detectTimeZone } = require('@smhg/date-time-zone');

if (!detectTimeZone()) {
  console.warn('Time zones not (fully) supported');
}

const timeZone = 'Europe/Berlin';
createDate({ timeZone }); // now

createDate(2019, 0, 1, { timeZone }); // start of 2019 in Berlin

const date = createDate({ timeZone });
date.setHours(0, 0, 0, 0);
console.log(date.toString()); // start of today in Berlin
```

## Usage
When you need to work with a Date instance in another time zone, replace `new Date` with `createDate` and add an options object (`{ timeZone: '...' }`) as the last parameter.

All other usage is the same as regular Date objects, with manipulations (`setDate`, `setHours`, ...) happening in the specified time zone and `toString()` returning the date and time in the specified time zone.
npm package: @smhg/microdata
Description: Schema.org microdata parser
Author: Sam Hauglustaine
Latest version: 0.2.0

# microdata [![Build Status](https://travis-ci.org/smhg/microdata-js.png?branch=master)](https://travis-ci.org/smhg/microdata-js)

  [schema.org](http://schema.org/) microdata parser.

  Tests based on tests in microdatajs by Philip Jägenstedt.

## Installation

```
npm install @smhg/microdata
```

## Usage

```javascript
import {parse} from 'microdata';

let microdata = parse('<html><!-- ... --></html>');
```

## TODO
* cli interface
* parse more schema.org elements (e.g. time values)
* give meaning to itemprop values (Date, interval, Number)
* optionally map itemtype values to something useful (other than url)
npm package: @smicolon/cli
Description: CLI for installing smi-ui components
Author: Smicolon
Latest version: 0.3.1

# @smicolon/cli

[![npm version](https://img.shields.io/npm/v/@smicolon/cli.svg)](https://www.npmjs.com/package/@smicolon/cli)
[![npm downloads](https://img.shields.io/npm/dm/@smicolon/cli.svg)](https://www.npmjs.com/package/@smicolon/cli)
[![license](https://img.shields.io/npm/l/@smicolon/cli.svg)](https://github.com/smicolon/smi-ui/blob/main/LICENSE)

CLI for installing [@smicolon/smi-ui](https://www.npmjs.com/package/@smicolon/smi-ui) components into your React project. Works like shadcn/ui CLI - components are copied directly into your codebase for full customization.

## Quick Start

```bash
# Initialize in your project
npx @smicolon/cli init

# Add components
npx @smicolon/cli add button card input

# List all available components
npx @smicolon/cli list
```

## Commands

### `init`

Initialize smi-ui in your project. Creates a `components.json` configuration file.

```bash
npx @smicolon/cli init

# Skip prompts with defaults
npx @smicolon/cli init -y
```

### `add <component...>`

Add one or more components to your project. Components are copied to your configured directory.

```bash
# Add a single component
npx @smicolon/cli add button

# Add multiple components at once
npx @smicolon/cli add button input textarea card

# Add effect components
npx @smicolon/cli add shimmer-button animated-gradient

# Add app blocks
npx @smicolon/cli add app-shell page-header data-table
```

### `list`

List all available components organized by category.

```bash
npx @smicolon/cli list
```

## Available Components

### UI Primitives
`avatar` `badge` `button` `card` `checkbox` `combobox` `input` `select` `skeleton` `switch` `tabs` `textarea`

### App Blocks
`app-shell` `data-table` `empty-state` `form-section` `navbar` `page-header` `sidebar` `stats-card`

### Effects
`animated-gradient` `border-beam` `glow-card` `shimmer-button` `spotlight` `text-reveal` `typewriter-text`

## Requirements

- **Node.js** 18+
- **React** 18+
- **Tailwind CSS** configured in your project
- **TypeScript** (recommended)

## How It Works

Unlike traditional npm packages, this CLI copies component source code directly into your project:

1. `init` creates a `components.json` with your project configuration
2. `add` downloads and copies components to your configured directory
3. You own the code - customize freely without package updates

This approach gives you full control over styling and behavior.

## Documentation

Visit [ui.smicolon.com](https://ui.smicolon.com) for:
- Component documentation and examples
- Installation guides
- Customization tips
- Design token reference

## Related

- [@smicolon/smi-ui](https://www.npmjs.com/package/@smicolon/smi-ui) - The component library
- [shadcn/ui](https://ui.shadcn.com) - Inspiration for this approach

## License

MIT
npm package: @smidges/aws-es-connection
Description: Custom Connection for Signing with AWS Credentials using the official Elasticsearch Node Client
Author: Nick Smider
Latest version: 1.0.0

# aws-es-connection

## Purpose

When restricting AWS Elasticsearch to an IAM user/role, requests need to be signed to be accepted.

There is an [outdated connection package for the legacy elasticsearch client](https://github.com/TheDeveloper/http-aws-es), but there is no packaged for for the newewst `@elastic/elasticsearch` client, until now.

This is based on code provided in an [issue](https://github.com/elastic/elasticsearch-js/issues/951) on the client's repo. I adapted the example to be used from an npm package.
## Usage

### Install

```bash
npm i @smidges/aws-es-connection
```

### Peer Dependencies

You must install these packages along side as they will not be included by default.

```bash
npm install aws-sdk @elastic/elasticsearch
```

### Region

AWS Region has to be defined in order to sign the requests.

Either `AWS.config.region` or `process.env.AWS_DEFAULT_REGION` should be set to the region of choice.

### Credentials

The package assumes `AWS.config.credentials` is configured already with the correct role needed to access Elasticsearch.

```typescript
import { Client, Connection } from '@elastic/elasticsearch';
import { AwsSignedConnection } from '@smidges/aws-es-connection';
import * as AWS from 'aws-sdk';


const client = new Client({
  node: 'https://<unique-url>.us-east-1.es.amazonaws.com',
  Connection: AWS.config.credentials ? AwsSignedConnection : Connection,
});
```
npm package: @smidswater/postcss-conditionals
Description: PostCSS plugin that enables @if statements in your CSS
Author: Andy Jansson
Latest version: 3.0.1

# postcss-conditionals [![Build Status][ci-img]][ci]

[PostCSS] plugin that enables ```@if``` statements in your CSS.

[PostCSS]: https://github.com/postcss/postcss

## Installation

```js
npm install @smidswater/postcss-conditionals
```

## Usage

```js
var fs = require('fs');
var postcss = require('postcss');
var conditionals = require('@smidswater/postcss-conditionals');

var css = fs.readFileSync('input.css', 'utf8');

var output = postcss()
  .use(conditionals)
  .process(css)
  .css;
```

Using this ```input.css```:

```css
.foo {
  @if 3 < 5 {
    background: green;
  }
  @else {
    background: blue;
  }
}
```

you will get:

```css
.foo {
  background: green;
}
```

Also works well with [postcss-simple-vars]:

```css
$type: monster;
p {
  @if $type == ocean {
    color: blue;
  } @else if $type == matador {
    color: red;
  } @else if $type == monster {
    color: green;
  } @else {
    color: black;
  }
}
```
[postcss-simple-vars]: https://github.com/postcss/postcss-simple-vars

and with [postcss-for]:

```css
@for $i from 1 to 3 {
  .b-$i {
    width: $i px;
    @if $i == 2 {
      color: green;
    }
  }
}
```

[postcss-for]: https://github.com/antyakushev/postcss-for

## Development
1. Clone repository
2. Install dependencies `npm install`
3. If `parser.jison` file has been changed, regenerate `parser.js` by running `npm run gen-parser`
npm package: @smiileteam/smiile-publish
Description: Add the possibility to publish your content to the Smiile social network within your software.
Author: Smiile Development Team
Latest version: 1.0.2

# Smiile Publish

Official Smiile library to publish content from an external website (yours ;-) to Smiile.

## Getting Started

### With CDN
```html
<!-- Use standard HTML tag to let you customize appearance of your button. -->
<button id="smiileShare_1">My publication button</button>
<script src="https://unpkg.com/@smiileteam/smiile-publish/dist/smiile-publish.min.js"></script>
<script>
    const publisher = new SmiilePublish();
    document.getElementById('smiileShare_1').addEventListener('click', () => publisher.publish({
        description: "Your content to upload", // The text content and url to upload on your Smiile network
        medias: [] // Url array of images to share with your post
    }));
</script>
```


### With npm

```bash
npm i @smiileteam/smiile-publish
```

```js
import {SmiilePublish} from '@smiileteam/smiile-publish';
const publisher = new SmiilePublish();
document.getElementById('smiileShare_1').addEventListener('click', () => publisher.publish({
    description: "Your content to upload", // The text content and url to upload on your Smiile network
    medias: [] // Url array of images to share with your post
}));
```


### Custom implementation

Our mecanism is really simple. It is just a POST call to [Smiile API](https://www.smiile.com/api/doc/publish) that will return to you the url to open in
a new window. You can see our readable implementation of this in [the non minified source code](src/smiile-publish.js).

For tests and while developing, please use our demo environnement
```js
const publisher = new SmiilePublish({apiDomain: 'demo-api.smiile.com'});
```

## Build and tests

```bash
npm install
npm run build
npm run test
```
npm package: @smiirl/smiirl-library-js
Description: A node package to simplify interactions with Smiirl objects
Author: Smiirl
Latest version: 1.0.5

# smiirl-library-js
To use the library, you need to install this library with npm.

```bash
npm install smiirl/smiirl-library-js
```

## Usage

### Generate json response
```javascript
const { Counter } = require("@smiirl/smiirl-library-js");
Counter.jsonResponse(12345);
Counter.stringResponse(12345);
```

### Reset to 0

```javascript
const { Counter } = require("@smiirl/smiirl-library-js");
// Get the real values from your counter in https://my.smiirl.com
const mac = "e08e00000000";
const token = "abcdef123456";
const counter = new Counter(mac, token);
counter.reset().then(function(json) {
    console.log("Counter Reset Response", json)
})
```

### Push a number

```javascript
counter.push(12345).then(function(json) {
    console.log("Counter Push Response", json)
})
```

### Add a number to the current value

```javascript
counter.add(21).then(function(json) {
    console.log("Counter Add Response", json)
})
```

## Custom Counters

Smiirl Custom Counters are available on our website [https://www.smiirl.com](https://www.smiirl.com).
npm package: @smikhalevski/codegen
Description: Language-agnostic codegen utils.
Author: Savva Mikhalevski
Latest version: 2.0.1
Deprecated: Migrated to https://www.npmjs.com/package/codedegen

# codegen [![build](https://github.com/smikhalevski/codegen/actions/workflows/master.yml/badge.svg?branch=master&event=push)](https://github.com/smikhalevski/codegen/actions/workflows/master.yml)

Language-agnostic codegen utils.

```shell
npm install --save-prod @smikhalevski/codegen
```

# Usage

⚠️ [API documentation is available here.](https://smikhalevski.github.io/codegen/)

```ts
import {template as _, compileJsSource} from '@smikhalevski/codegen';

const kebabVar = _.var();
const indexVar = _.var();
const valueVar = _.var();

const functionBlock = _.block`function makeKebab(${valueVar}){${[
  _`let ${kebabVar};`,
  _.assignment(kebabVar, _`""`),

  _`for(let ${indexVar}=0;${indexVar}<${valueVar}.length;${indexVar}++){`,
  _`${kebabVar}+="-"+${valueVar}.charAt(${indexVar});`,
  _`}`,

  _`return ${kebabVar}`,
]}}`;

compileJsSource(functionBlock);
// → 'function makeKebab(a){let b;b="";for(let c=0;c<a.length;c++){b+="-"+a.charAt(c);}return b}'
```

Codegen can optimize code by inlining assignments and eliminating redundant variable declarations.

```ts
import {template as _, compileJsSource, inlineVarAssignments} from '@smikhalevski/codegen';

const aVar = _.var();
const bVar = _.var();
const cVar = _.var();

const block = _(
    _.assignment(aVar, 3),
    _.assignment(bVar, 2),
    _.assignment(cVar, _`${aVar}+${bVar}`),

    _`console.log(${cVar})`,
);

// This operation mutates block
inlineVarAssignments(block);

compileJsSource(block);
// → 'console.log(3+2)'
```
npm package: @smikhalevski/event-bus
Description: Yet another event bus.
Author: Savva Mikhalevski
Latest version: 1.0.0

# event-bus [![build](https://github.com/smikhalevski/event-bus/actions/workflows/master.yml/badge.svg?branch=master&event=push)](https://github.com/smikhalevski/event-bus/actions/workflows/master.yml)

Yet another event bus. There are many like it, but this one is mine.

The most primitive implementation of a push-based event bus (pub/sub) that you can find.

```shell
npm install --save-prod @smikhalevski/event-bus
```

```ts
import {EventBus} from '@smikhalevski/event-bus';

interface IFooEvent {
  foo: string;
}

const eventBus = new EventBus<IFooEvent>();

const unsubscribe = eventBus.subscribe((event) => console.log(event.foo));

eventBus.publish({foo: 'abc'}); // Outputs "abc" to console

unsubscribe();
```
npm package: @smikhalevski/json-bigint
Description: The symmetrical and backwards compatible JSON serializer/parser with bigint support.
Author: Savva Mikhalevski
Latest version: 1.0.0

# json-bigint

The symmetrical, backward compatible, and unambiguous JSON serializer/parser with bigint support.

```shell
npm install --save @smikhalevski/json-bigint
```

# Usage

Integers from JSON are parsed as `BigInt` while float numbers are parsed as `number`. 

```ts
import * as JsonBigInt from '@smikhalevski/json-bigint';

JsonBigInt.stringify({foo: 123n, bar: 123}); // → '{"foo":123,"bar":123.0}'

JsonBigInt.parse('{"foo":123,"bar":123.0}'); // → {foo: 123n, bar: 123}
```

You can create custom parsers and serializers:

```ts
import bigint from 'bigint';
import {createJsonParser, createJsonStringifier} from '@smikhalevski/json-bigint';

const stringifyJson = createJsonStringifier({
  isBigInt: (value) => value instanceof bigint,
  stringifyBigInt: (value) => value.toString(),
});

const parseJson = createJsonParser({
  parseBigInt: (str) => bigint(str),
});

stringifyJson({foo: bigint(123), bar: 123}); // → '{"foo":123,"bar":123.0}'

parseJson('{"foo":123,"bar":123.0}'); // → {foo: bigint(123), bar: 123}
```

# Performance

Clone this repo and use `npm ci && npm run perf` to run the performance testsuite.

Results are in operations per second. The higher number is better.

|  | native JSON | @smikhalevski/json-bigint | [@sidorares/json-bigint](https://github.com/sidorares/json-bigint) |
| --------- | ---: | ---: | ---: |
| parse     | 49 352 | 15 136 | 8 874  |
| stringify | 55 066 | 27 529 | 17 210 |
npm package: @smikhalevski/object-pool
Description: The tiny and efficient object pool.
Author: Savva Mikhalevski
Latest version: 1.0.0

# object-pool [![build](https://github.com/smikhalevski/object-pool/actions/workflows/master.yml/badge.svg?branch=master&event=push)](https://github.com/smikhalevski/object-pool/actions/workflows/master.yml)

[The tiny](https://bundlephobia.com/package/@smikhalevski/object-pool) and efficient object pool.

This implementation was inspired by [deePool](https://github.com/getify/deePool) and is slightly faster than the
original.

```shell
npm install @smikhalevski/object-pool
```

# Usage

```ts
import {ObjectPool} from '@smikhalevski/object-pool';

const pool = new ObjectPool(() => {
  // Create and return a heavy object.
}, (value) => {
  // Reset the released object. 
});

// Prepare 100 heavy objects.
pool.allocate(100);

// Take a heavy object from the pool.
const heavyObject = pool.take();

// Return heavy object back to the pool.
pool.release(heavyObject);
```
npm package: @smikhalevski/perf-test
Description: The Node.js performance testing tool.
Author: Savva Mikhalevski
Latest version: 1.0.0
Deprecated: Migrated to https://www.npmjs.com/package/toofast

# perf-test

The Node.js performance testing tool.

```shell
npm install --save-dev @smikhalevski/perf-test
```

⚠️ [API documentation is available here.](https://smikhalevski.github.io/perf-test/)

## Usage

Measure performance of a callback:

```js
const {test} = require('@smikhalevski/perf-test');

function callback() {
  // The code you want to test goes here
}

test('My test', callback, {timeout: 3000});
// stdout: "My test 7,331,041.16 ops/sec ± 0.19%"
```

Measure performance of a callback across a population of values:

```js
const {valueTest} = require('@smikhalevski/perf-test');

function callback(value) {
  // value is 1, 2 or 3 
  // The code you want to test goes here
}

valueTest([1, 2, 3], 'My test', callback, {timeout: 3000});
// stdout: "My test 7,331,041.16 ops/sec ± 0.19%"
```

Get programmatic access to the test result statistics:

```js
const {createHistogram, cycle} = require('@smikhalevski/perf-test');

function callback() {
  // The code you want to test goes here
}

const histogram = createHistogram();

cycle(callback, histogram, {timeout: 3000});

histogram.getHz(); // → 7331041.16
```
npm package: @smikhalevski/react-html-renderer
Description: Renders HTML source as React nodes using customizable element renderer.
Author: Savva Mikhalevski
Latest version: 1.0.1
Deprecated: Migrated to react-dom-renderer

# react-html-renderer [![build](https://github.com/smikhalevski/react-html-renderer/actions/workflows/master.yml/badge.svg?branch=master&event=push)](https://github.com/smikhalevski/react-html-renderer/actions/workflows/master.yml)

Renders HTML source as React nodes using customizable element renderer.

```shell
npm install --save-prod @smikhalevski/react-html-renderer
```

# Usage

Render an HTML as React nodes.

```tsx
import {HtmlRenderer} from '@smikhalevski/react-html-renderer';

const MyComponent = () => (
    <HtmlRenderer value={'<b>Hello</b>, world'}/>
);
// → <><b>Hello</b>, world</>
```

Use the custom element renderer.

```tsx
import {ElementRenderer, HtmlRenderer} from '@smikhalevski/react-html-renderer';

const elementRenderer: ElementRenderer = (tagName) => {
  // Tag names are lower cased
  if (tagName === 'bear') {
    return <strong>{'Bonjour'}</strong>;
  }
  // Forest tag is ignored
};

const MyComponent = () => (
    <HtmlRenderer
        value={'<Bear><Forest>'}
        elementRenderer={elementRenderer}
    />
);
// → <strong>Bonjour</strong>
```

Use customized DOM parser.

In this example we are going to initialize a parser that recognizes custom HTML entities.

Have a look at [TagSoup](https://github.com/smikhalevski/tag-soup)
and [speedy-entities](https://github.com/smikhalevski/speedy-entities) for more details on configuration.

```tsx
import {DomParserContext, ElementRenderer, HtmlRenderer} from '@smikhalevski/react-html-renderer';
import {createEntityDecoder, createEntityManager} from 'speedy-entities';
import {createHtmlDomParser, domHandler} from 'tag-soup';

const entityManager = createEntityManager();

entityManager.set('wtfisthis', 'This is Sparta');

const parser = createHtmlDomParser(domHandler, {
  decodeText: createEntityDecoder(entityManager),
});

const result = render(
    <DomParserContext.Provider value={parser}>
      <HtmlRenderer value={'&wtfisthis;'}/>
    </DomParserContext.Provider>
);
// → <>This is Sparta</>
```
npm package: @smikhalevski/route-pattern
Description: The path pattern parser, that supports named variables, variable constraints, bash-like alternation, regular expressions, and wildcards.
Author: Savva Mikhalevski
Latest version: 1.0.1

# route-pattern [![Build Status](https://travis-ci.com/smikhalevski/route-pattern.svg?branch=master)](https://travis-ci.com/smikhalevski/route-pattern)

The path pattern parser, that supports named variables, variable constraints, bash-like alternation, regular
expressions, and wildcards.

This package is
tiny, [just 2.2 kB gzipped including dependencies.](https://bundlephobia.com/package/@smikhalevski/route-pattern)

```sh
npm install --save-prod @smikhalevski/route-pattern
```

# Usage

```ts
import {convertPatternToRegExp} from '@smikhalevski/route-pattern';

const re = convertPatternToRegExp('/(\\d+)/:foo{ bar, qux }');
const match = re.exec('/123/bar');

console.log(match?.groups?.foo); // → 'bar'
```

The support of named capturing groups **is not required** from the environment.

# Features

`/foo/bar` is a literal path that is matched as is.

Spaces, tabs, and newlines are ignored, so `/ foo / bar` is the same as `/foo/bar`, and `/foo  bar` is the same
as `/foobar` (note the absent spaces).

If you want to preserve spaces, use quotes: `/" foo bar"`.

## Regular expression

`(\\d+)` declares a regular expression, spaces have meaning inside a regular expression.

RegExps can contain a named capturing groups which are merged with variables. For example, `/:foo/(?<bar>abc)` would
match `/123/abc` and groups would be `{foo: '123', bar: 'abc'}`.

## Wildcards

`*` declares a wildcard that matches everything except the path separator. For example, `/foo/*/bar` would
match `/foo/okay/bar` and `/foo//bar` but won't match `/foo/no/sir/bar`.

`**` declares a greedy wildcard that matches everything, even path separators. For example, `/foo/**/bar` would
match `/foo/okay/bar`, `/foo//bar` and `/foo/no/sir/bar`.

If you want to match at least one character, use a regular expression instead of a wildcard. For
example, `/foo/([^/]+)/bar` would match `/foo/okay/bar` and won't match `/foo//bar`.

## Alternation

`{ foo, bar }` declares an alternation: `foo` or `bar`.

Alternation supports nesting, for example `/foo{ -bar, /(\\d+)/qux }` would match `/foo-bar` and `/foo/123/qux`.

## Variables

`:foo` declares a variable. Variable name should match `^[A-Za-z0-9$_]+$`.

By default, variables match everything except the path separator.

A single pattern that immediately follows the variable declaration is treated as a variable constraint. For example,`:foo bar` and `:foo"bar"` would both read variable `foo` and treat `bar` as its string literal constraint.

`:foo(\\d+)` declares a variable whose value is constrained by a regular expression.

`:foo{ a, b }` declares a variable whose value is constrained by an alternation.

`:foo{**}` variables can be constrained with wildcards.

Variables can be nested through an alternation: `/aaa/ :foo{ /bbb, /ccc/:bar }`.

Variables are not treated as constraints for other variables. For example, `:foo:bar{abc}` would match `123abc` and
groups would be `{foo: '123', bar: 'abc'}`.
npm package: @smikitky/rb-components
Description: Components for React-Bootstrap
Author: Soichiro Miki
Latest version: 7.0.0

# React-Bootstrap Components

Project-agnostic component sets used with react-bootstrap.

# Usage

Like other components of react-bootstrap, package consumers should
directly `require` or `import` components in the `lib` directory.

```js
import IconButton from '@smikitky/rb-components/lib/IconButton';
```

These are written in ES2015 with `object-rest-spread`,
so you'll need to transpile them using Babel or TypeScript set up for your project.
Scripts in `node_modules` are often configured to be ignored, so you may have to
specify that scripts under `@smikitky/rb-components` should be transpiled.

Aliasing to the `rb-components/lib` is also a good idea.

Therefore your `webpack.config.js` would look like this:

```js
loaders: [{
  test: t => (/\.jsx?/.test(t) && (/rb-components/.test(t) || !/node_modules/.test(t))),
  loader: 'babel-loader',
  query: {
    presets: ['es2015', 'react'],
    plugins: ['transform-object-rest-spread']
  }
}],
resolve: {
  modules: ['front-ui'],
  alias: { rb: '@smikitky/rb-components/lib' },
}
```

Polyfill scripts (like Promises) are not included.
You should provide your own polyfills if necessary.

# Requirements

The followings should be manually enabled in your project:

- Font Awesome (CSS, optional)
- Bootstrap (CSS Only)

These packages are marked as `dependencies`. These will not be included
in your final bundle unless you actually use the relevant components.

- `classnames`
- `moment`
- `tinycolor2`

# Demo

A small demo app is available via webpack-dev-server.

```
npm start
```

# Note

This package is basically intended for internal use only.

# License

MIT