open-index/open-npm huggingface dataset:
npm package: @ruva-soft/components
Description: A collection of reusable components for building Angular applications, as well as for use in other frameworks and libraries.
Author: David Sundersingh
Latest version: 0.1.0

# @ruva-soft/components

The `@ruva-soft/components` library is a collection of reusable UI components for Angular applications. It provides a set of pre-built components that can be easily integrated into your projects, promoting code reusability and enhancing development efficiency.

## Features

- Ready-to-use UI components for common use cases.
- Well-documented API and usage examples for each component.
- Customizable styles using CSS and SASS.

## Installation

Install the `@ruva-soft/components` library by running the following command:

npm install @ruva-soft/components

## Usage

Import the desired components from `@ruva-soft/components` in your Angular module and start using them in your templates.

```typescript
import { Component1Module, Component2Module } from '@ruva-soft/components';

@NgModule({
  imports: [
    // Other module imports
    Component1Module,
    Component2Module,
  ],
  // ...
})
export class AppModule {}
```

## Contributing

Contributions to the `@ruva-soft/components` library are welcome! If you find any issues or have suggestions for improvements, please feel free to open an issue or submit a pull request on the GitHub repository.

## License

This library is released under the [MIT License](https://opensource.org/licenses/MIT).

## Credits

The @ruva-soft/components package is developed and maintained by Ruvasoft Solutions Inc.
npm package: @ruva-soft/services
Description: A collection of reusable services for building Angular applications, as well as for use in other frameworks and libraries.
Author: David Sundersingh
Latest version: 0.2.0

# @ruva-soft/services

The @ruva-soft/services package provides a set of reusable services to handle common tasks related to connection of API services using authentication such as token, oauth, jwt, saml and any custom authentication method. This can help to reduce duplication of code and improve code quality and maintainability across enterprise Angular projects.

## Installation

To install the package, run the following command:

`npm install @ruva-soft/services`

## Usage

The package provides the APIService which can be injected and used to perform HTTP requests with custom parameters such as tokens. Here is an example of how to use the APIService:

```typescript
import { Injectable } from '@angular/core';
import { APIService } from '@ruva-soft/services';

@Injectable({
  providedIn: 'root'
})
export class MyService {
  constructor(private apiService: APIService) {}

  getData() {
    // Add custom parameters
    const params = {
      token: 'mytoken'
    };

    return this.apiService.getWithParams('/data', params);
  }
}
```

## License

This package is open source and released under the MIT License. See the [LICENSE](./LICENSE) file for details.


## Credits

The @ruva-soft/services package is developed and maintained by Ruvasoft Solutions Inc.
npm package: @ruvasik/react-region-svg-map
Description: 🗺️ A React component for interactive vector maps of the world and 100+ countries
Author: Vladimir Alekseev
Latest version: 0.3.4

# react-vector-maps

🗺️ A React component for interactive vector maps of the world and 100+ countries

[![npm](https://img.shields.io/npm/v/@south-paw/react-vector-maps.svg)](https://www.npmjs.com/package/@south-paw/react-vector-maps)

## Features

- Simple and easy to implement React component for rendering interactive vector maps
- [100+ vector maps included](https://react-vector-maps.netlify.com/maps) out of the box, free from [MapSVG](https://mapsvg.com/maps)
- Convert your own vector map for the component to use with the [online converter](https://react-vector-maps.netlify.com/converter)
- Quick and straight forward to style your map however you want to

## Basic Usage

```jsx
import React from 'react';
import { VectorMap } from '@south-paw/react-vector-maps';

// You'll need to download the json file from the docs site or you can create your own.
import world from './world.json';

export const Map = () => <VectorMap {...world} />;
```

See the [documentation](https://react-vector-maps.netlify.com/) for more examples and advanced usage of the component.

## Issues and Bugs

If you manage to find any, please report them [here](https://github.com/South-Paw/react-vector-maps/issues) so they can be squashed.

## Development and Contributing

Grab the repo and then install dependencies with `npm i`.

```bash
# Run TypeScript check and ESLint
npm run lint

# Run unit tests
npm run test

# Build package for publishing (/dist)
npm run build

# Remove build artifacts (/dist and /coverage)
npm run clean

# npm install for the docs
npm run docs:install

# Start docs for development
npm run docs:start

# Build docs for deployment
npm run docs:build

# Serve docs from /public after build
npm run docs:serve

# Clean up docs folders
npm run docs:clean
```

## License

MIT, see the [LICENSE](./LICENSE) file.
npm package: @ruvector/economy-wasm
Description: CRDT-based autonomous credit economy for distributed compute networks - WASM optimized
Author: RuVector Team
Latest version: 0.1.29

# @ruvector/economy-wasm

CRDT-based autonomous credit economy for distributed compute networks - WASM optimized.

## Features

- **CRDT-Based**: Conflict-free Replicated Data Types for eventual consistency
- **Autonomous Credits**: Self-managing credit system for compute resources
- **P2P Reputation**: Decentralized reputation tracking
- **Byzantine Fault Tolerant**: Handles malicious actors gracefully

## Installation

```bash
npm install @ruvector/economy-wasm
```

## Usage

```javascript
import init, { CreditEconomy, ReputationSystem } from '@ruvector/economy-wasm';

await init();

// Create an economy instance
const economy = new CreditEconomy();

// Create agents and allocate credits
economy.createAgent("agent-1", 1000);

// Transfer credits between agents
economy.transfer("agent-1", "agent-2", 100);

// Track reputation
const reputation = new ReputationSystem();
reputation.recordSuccess("agent-1", "task-123");
```

## Architecture

- **GCounter/PNCounter**: For credit tracking
- **ORSet**: For agent membership
- **LWWRegister**: For reputation scores

## License

MIT

## Links

- [GitHub Repository](https://github.com/ruvnet/ruvector)
- [Documentation](https://ruv.io)
npm package: @ruvector/exotic-wasm
Description: Exotic AI mechanisms for emergent behavior - Neural Autonomous Orgs, Morphogenetic Networks, Time Crystals
Author: RuVector Team
Latest version: 0.1.29

# @ruvector/exotic-wasm

Exotic AI mechanisms for emergent behavior - Neural Autonomous Orgs, Morphogenetic Networks, Time Crystals.

## Features

- **Neural Autonomous Organizations (NAOs)**: Self-organizing neural collectives
- **Morphogenetic Networks**: Pattern formation inspired by biological development
- **Time Crystals**: Periodic structures for temporal pattern recognition
- **Emergent Behavior**: Complex behaviors from simple rules

## Installation

```bash
npm install @ruvector/exotic-wasm
```

## Usage

```javascript
import init, {
  NeuralAutonomousOrg,
  MorphogeneticNetwork,
  TimeCrystal
} from '@ruvector/exotic-wasm';

await init();

// Create a Neural Autonomous Org
const nao = new NeuralAutonomousOrg(config);
nao.evolve(generations);

// Create a Morphogenetic Network
const morpho = new MorphogeneticNetwork(size);
morpho.develop(steps);

// Create a Time Crystal
const crystal = new TimeCrystal(period);
crystal.oscillate(input);
```

## Concepts

### Neural Autonomous Orgs
Self-organizing collectives that evolve governance structures through neural consensus.

### Morphogenetic Networks
Networks that develop complex structures through local interaction rules, inspired by embryonic development.

### Time Crystals
Discrete time-periodic structures that maintain temporal patterns for sequence processing.

## License

MIT

## Links

- [GitHub Repository](https://github.com/ruvnet/ruvector)
- [Documentation](https://ruv.io)
npm package: @ruvector/graph-node
Description: Native Node.js bindings for RuVector Graph Database with hypergraph support, Cypher queries, and persistence - 10x faster than WASM
Author: ruv.io Team
Latest version: 2.0.3

# @ruvector/graph-node

Native Node.js bindings for RuVector Graph Database with hypergraph support, Cypher queries, and persistence. **10x faster than WASM**.

## Features

- **Native Performance**: Direct NAPI-RS bindings - no WASM overhead
- **Hypergraph Support**: Multi-node relationships with vector embeddings
- **Cypher Queries**: Neo4j-compatible query language
- **Persistence**: ACID-compliant storage with redb backend
- **Vector Similarity Search**: Fast k-NN search on embeddings
- **Graph Traversal**: k-hop neighbor discovery
- **Transactions**: Full ACID support with begin/commit/rollback
- **Batch Operations**: High-throughput bulk inserts (131K+ ops/sec)
- **Zero-Copy**: Efficient Float32Array handling
- **TypeScript**: Full type definitions included

## Installation

```bash
npm install @ruvector/graph-node
```

## Quick Start

```javascript
const { GraphDatabase } = require('@ruvector/graph-node');

// Create an in-memory database
const db = new GraphDatabase({
  distanceMetric: 'Cosine',
  dimensions: 384
});

// Or create a persistent database
const persistentDb = new GraphDatabase({
  distanceMetric: 'Cosine',
  dimensions: 384,
  storagePath: './my-graph.db'
});

// Or open an existing database
const existingDb = GraphDatabase.open('./my-graph.db');

// Create nodes
await db.createNode({
  id: 'alice',
  embedding: new Float32Array([1.0, 0.0, 0.0, /* ... */]),
  labels: ['Person', 'Employee'],
  properties: { name: 'Alice', age: '30' }
});

// Create edges
await db.createEdge({
  from: 'alice',
  to: 'bob',
  description: 'KNOWS',
  embedding: new Float32Array([0.5, 0.5, 0.0, /* ... */]),
  confidence: 0.95
});

// Create hyperedges (multi-node relationships)
await db.createHyperedge({
  nodes: ['alice', 'bob', 'charlie'],
  description: 'COLLABORATED_ON_PROJECT',
  embedding: new Float32Array([0.33, 0.33, 0.33, /* ... */]),
  confidence: 0.85
});

// Query with Cypher
const results = await db.query('MATCH (n:Person) RETURN n');

// Vector similarity search
const similar = await db.searchHyperedges({
  embedding: new Float32Array([0.3, 0.3, 0.3, /* ... */]),
  k: 10
});

// Get statistics
const stats = await db.stats();
console.log(\`Nodes: \${stats.totalNodes}, Edges: \${stats.totalEdges}\`);
```

## Benchmarks

| Operation | Throughput | Latency |
|-----------|------------|---------|
| Node Creation | 9.17K ops/sec | 109ms |
| Batch Node Creation | 131.10K ops/sec | 7.63ms |
| Edge Creation | 9.30K ops/sec | 107ms |
| Vector Search (k=10) | 2.35K ops/sec | 42ms |
| k-hop Traversal | 10.28K ops/sec | 9.73ms |

## Platform Support

| Platform | Architecture | Status |
|----------|--------------|--------|
| Linux | x64 (glibc) | Supported |
| Linux | arm64 (glibc) | Supported |
| macOS | x64 | Supported |
| macOS | arm64 (M1/M2) | Supported |
| Windows | x64 | Supported |

## License

MIT
npm package: @ruvector/nervous-system-wasm
Description: WASM bindings for ruvector-nervous-system bio-inspired AI components - HDC, BTSP, neuromorphic computing
Author: RuVector Team
Latest version: 0.1.29

# @ruvector/nervous-system-wasm

WASM bindings for bio-inspired AI components - Hyperdimensional Computing (HDC), Behavioral Time-Scale Plasticity (BTSP), and neuromorphic computing.

## Features

- **Hyperdimensional Computing (HDC)**: High-dimensional vector operations for cognitive computing
- **Behavioral Time-Scale Plasticity (BTSP)**: Biologically-inspired learning mechanisms
- **Neuromorphic Computing**: Brain-inspired computing primitives
- **Spiking Neural Networks**: Event-driven neural computation

## Installation

```bash
npm install @ruvector/nervous-system-wasm
```

## Usage

```javascript
import init, {
  HyperdimensionalMemory,
  BTSPNeuron,
  SpikingNetwork
} from '@ruvector/nervous-system-wasm';

await init();

// Create HDC memory
const hdc = new HyperdimensionalMemory(dimension);
hdc.encode("concept", data);
const similar = hdc.query(vector);

// Create BTSP neuron
const neuron = new BTSPNeuron(config);
neuron.process(input);

// Create spiking network
const snn = new SpikingNetwork(topology);
snn.simulate(spikes, duration);
```

## Components

### Hyperdimensional Computing
- Binary/bipolar hypervectors
- Bundling and binding operations
- Similarity search

### BTSP Learning
- Plateau potentials
- Dendritic computation
- Temporal credit assignment

### Neuromorphic Primitives
- Leaky integrate-and-fire neurons
- STDP learning
- Spike encoding/decoding

## License

MIT

## Links

- [GitHub Repository](https://github.com/ruvnet/ruvector)
- [Documentation](https://ruv.io)
npm package: @ruvector/rvf-mcp-server
Description: MCP server for RuVector Format (RVF) vector database — stdio and SSE transports
Latest version: 0.1.4

# @ruvector/rvf-mcp-server

MCP (Model Context Protocol) server for RuVector Format (RVF) vector stores. Exposes RVF capabilities to AI agents like Claude Code, Cursor, and other MCP-compatible tools.

## Install

```bash
npx @ruvector/rvf-mcp-server --transport stdio
```

## Claude Code Integration

Add to your MCP config:

```json
{
  "mcpServers": {
    "rvf": {
      "command": "npx",
      "args": ["@ruvector/rvf-mcp-server", "--transport", "stdio"]
    }
  }
}
```

## Transports

```bash
# stdio (for Claude Code, Cursor, etc.)
npx @ruvector/rvf-mcp-server --transport stdio

# SSE (for web clients)
npx @ruvector/rvf-mcp-server --transport sse --port 3100
```

## MCP Tools

| Tool | Description |
|------|-------------|
| `rvf_create_store` | Create a new RVF vector store |
| `rvf_open_store` | Open an existing store |
| `rvf_close_store` | Close and release writer lock |
| `rvf_ingest` | Insert vectors with optional metadata |
| `rvf_query` | k-NN similarity search with filters |
| `rvf_delete` | Delete vectors by ID |
| `rvf_delete_filter` | Delete vectors matching a filter |
| `rvf_compact` | Compact store to reclaim space |
| `rvf_status` | Get store status |
| `rvf_list_stores` | List all open stores |

## MCP Resources

| URI | Description |
|-----|-------------|
| `rvf://stores` | JSON listing of all open stores |

## MCP Prompts

| Prompt | Description |
|--------|-------------|
| `rvf-search` | Natural language similarity search |
| `rvf-ingest` | Data ingestion with auto-embedding |

## Requirements

- Node.js >= 18.0.0

## License

MIT
npm package: @ruvector/rvf-wasm
Description: RuVector Format WASM microkernel for browser and edge vector operations
Latest version: 0.1.6

# @ruvector/rvf-wasm

RuVector Format (RVF) WASM build for browsers and edge functions. Query vectors directly in the browser with zero backend.

## Install

```bash
npm install @ruvector/rvf-wasm
```

## Usage

```html
<script type="module">
  import init, { WasmRvfStore } from '@ruvector/rvf-wasm';
  await init();

  const store = WasmRvfStore.create(384);
  store.ingest(1, new Float32Array(384));
  const results = store.query(new Float32Array(384), 10);
  console.log(results); // [{ id, distance }]
</script>
```

## Features

- ~46 KB control plane (full store API)
- ~5.5 KB tile microkernel (query-only)
- In-memory store with HNSW indexing
- Segment inspection and status
- No backend required

## License

MIT
npm package: @ruvents/leader-id-uikit
Description: Leader-ID UIkit
Author: Leader-ID team
Latest version: 1.47.86

# Leader-ID UIKit

Библиотека компонентов

## Технологический стек

- Vue
- Jest

## Код стайл

- Eslint
- Prettier
- Standard

## Соглашение по коммитам
- Адаптированная версия [Angular's commit convention](.github/COMMIT_CONVENTION.md)

## Разработка

``` bash
# Установка зависимостей
yarn install

# Запуск тестового стенда
yarn serve

# Запуск документации
yarn docs:dev
```

## Производство

```bash
# Построение сборки библиотеки
yarn build

# Построение сборки библиотеки и генерация статичной документации
yarn docs:build
```
npm package: @ruvents/yandex-metrika
Description: [![npm](https://img.shields.io/npm/dt/@nuxtjs/yandex-metrika.svg?style=flat-square)](https://www.npmjs.com/package/@nuxtjs/yandex-metrika) [![npm (scoped with tag)](https://img.shields.io/npm/v/@nuxtjs/yandex-metrika/latest.svg?style=flat-square)](https:/
Latest version: 1.4.0

# Yandex Metrika
[![npm](https://img.shields.io/npm/dt/@nuxtjs/yandex-metrika.svg?style=flat-square)](https://www.npmjs.com/package/@nuxtjs/yandex-metrika)
[![npm (scoped with tag)](https://img.shields.io/npm/v/@nuxtjs/yandex-metrika/latest.svg?style=flat-square)](https://www.npmjs.com/package/@nuxtjs/yandex-metrika)

> Add Yandex Metrika to your nuxt.js application.

This plugins automatically sends first page and route change events to yandex metrika.

**Note:** yandex metrika is not enabled in dev mode.
You can set environment variable `NODE_ENV` to `production` for testing in dev mode.

## Setup

- Add `@nuxtjs/yandex-metrika` dependency using yarn or npm to your project
- Add `@nuxtjs/yandex-metrika` to `modules` section of `nuxt.config.js`

```js
{
  modules: ['@nuxtjs/yandex-metrika'],
}
```

## Configure

You can pass options directly in module declaration:

```js
{
  modules: [
    [
      '@nuxtjs/yandex-metrika',
      {
        id: 'XXXXXX',
        webvisor: true,
        // clickmap: true,
        // useCDN: false,
        // trackLinks: true,
        // accurateTrackBounce: true,
      }
    ]
  ]
}
```

Or you can specify `yandexMetrika` key:

```js
{
  modules: ['@nuxtjs/yandex-metrika'],
  yandexMetrika: {
    id: 'XXXXXX',
    // ...
  }
}
```

In Nuxt 2.13+, you can also use public runtime config:

```js
{
  modules: ['@nuxtjs/yandex-metrika'],
  publicRuntimeConfig: {
    yandexMetrika: {
      id: process.env.YANDEX_METRIKA_ID,
      // ...
    }
  }
}
```

## Options

For more information:
- [Documetation for Ya.Metrika](https://yandex.com/support/metrica/code/counter-initialize.html)
- [hit method](https://yandex.com/support/metrica/objects/hit.html)

### `id`

- Required

### `useRuntimeConfig`

- Default: `yandexMetrika`

Public runtime config key. Set to `false` to disable runtime configuration.

### `useCDN`

- Default: false

Load metrika script from <https://cdn.jsdelivr.net/npm/yandex-metrica-watch/watch.js>.

This option can not be provided via runtime config.

### `accurateTrackBounce`
### `childIframe`
### `clickmap`
### `defer`
### `ecommerce`
### `params`
### `userParams`
### `trackHash`
### `trackLinks`
### `trustedDomains`
### `type`
### `ut`
### `webvisor`
### `triggerEvent`
npm package: @ruvice/my-maple-models
Description: Shared models and utils for MapleStory Nexon Open API
Author: Andrew Wee
Latest version: 1.1.3

# 📦 Publishing Guide

This document explains the simple workflow for releasing new versions of this npm package.

---

## 🚀 Releasing a New Version

Follow these steps whenever you want to publish an update to npm.

---

## ✅ 1. Build the package

If the project uses TypeScript or outputs compiled files to `dist/`, you must build before publishing:

```bash
npm run build

npm version patch    # 1.0.0 → 1.0.1
npm version minor    # 1.0.0 → 1.1.0
npm version major    # 1.0.0 → 2.0.0

npm publish --access public
npm publish
npm package: @ruwan.m.s/promise-utils
Description: ## Introduction Welcome to the documentation for the `@99xt/promise-utils` npm package! This package provides utility functions for working with Promises.
Author: Your Name
Latest version: 0.1.2

# @ruwan.m.s/promise-utils

## Introduction
Welcome to the documentation for the `@ruwan.m.s/promise-utils` npm package! This package provides utility functions for working with Promises.

## Installation
To install `@ruwan.m.s/promise-utils`, you can use npm. Open your terminal and run the following command:

```bash
npm install @ruwan.m.s/promise-utils
```

## Usage
Once you have installed the package, you can import it into your project using the following syntax:

### TypeScript (TS)
```typescript
import promiseUtils from '@ruwan.m.s/promise-utils';
```

### JavaScript (JS)
```javascript
const promiseUtils = require('@ruwan.m.s/promise-utils');
```


## API Reference
- `inlinePromise`: Function for executing a Promise inline. Return the as `[result, error]`
- `inlinePromiseObject`: Function for executing a Promise inline. Return the as `{data, error}`
- `inlinePromiseAll`: Function for executing an array of Promises inline using `Promise.all()`. Returns list of `[result, error]`
- `inlinePromiseObjectAll`: Function for executing an array of Promises inline using `Promise.all()`. Returns list of `{data, error}`


## Example Usage

Let's consider simple delay function

```javascript
const delay = (ms: number): Promise<number> => {
  return new Promise(resolve => setTimeout(() => resolve(ms), ms));
}
```

### inlinePromise()

Here's an example of how you can use the `inlinePromise` function:

```javascript
const [delayTime, error] = await inlinePromise(delay(300));
if (error) {
  // Error Handling
}

console.log(delayTime); // Output: 300
```

### inlinePromiseAll()

Here's an example of how you can use the `inlinePromiseAll` function:

```javascript
const res= await inlinePromiseAll([
    delay(200),
    delay(400),
]);

const [result1, error1] = res.next<number>();
console.log(result1) // Output: 200
const [result2, error2] = res.next<number>();
console.log(result2) // Output: 400
```


### inlinePromiseObject()

Here's an example of how you can use the `inlinePromise` function:

```javascript
  const {data: delayTime, error} = await inlinePromiseObject(delay(300))
if(error){
    // Error Handling
}
console.log(delayTime) // Output: 300
```

### inlinePromiseObject()

Here's an example of how you can use the `inlinePromiseObjectAll` function:

```javascript
const res= await inlinePromiseObjectAll([
    delay(200),
    delay(400),
]);

const {data:result1} = res.next<number>();
console.log(result1) // Output: 200
const {data:result2} = res.next<number>();
console.log(result2) // Output: 400
```
npm package: @ruwork/frujax
Description: A JavaScript library to send and process AJAX requests with ease.
Author: Valentin Udaltsov
Latest version: 0.8.1

# Frujax

A JavaScript library to send and process AJAX requests with ease.

## Installation

```html
<script src="https://code.jquery.com/jquery-3.3.1.slim.min.js"></script>
<script src="frujax.js"></script>
```

## Usage

```js
$('.frujax-btn').frujax({
    url: '/ajax',
    target: '#container'
});
```

Or you can use `data-frujax` attribute to quickly setup frujax on any element.

```html
<button data-frujax='{"url": "/ajax", "target": "#container"}'>Action!</button>
```

Clicking the link will load the contents of the `/ajax` page into the `#container` element.
npm package: @rux12/t_rex
Description: DFA based regex engine in typescript from scratch (not for production).
Author: Sangit Manandhar
Latest version: 1.0.1

<br />
<div align="center">
  <h3 align="center">T_REX</h3>

  <p align="center">
NFA/DFA based  Regex Machine
    <br />
</div>



<!-- TABLE OF CONTENTS -->
<details>
  <summary>Table of Contents</summary>
  <ol>
    <li>
      <a href="#about-the-project">About The Project</a>
      <ul>
      </ul>
    </li>
    <li>
      <a href="#getting-started">Getting Started</a>
      <ul>
        <li><a href="#installation">Installation</a></li>
      </ul>
    </li>
    <li><a href="#usage">Usage</a></li>
    <li><a href="#roadmap">Roadmap</a></li>
    <li><a href="#contact">Contact</a></li>
     <li><a href="#acknowledgments">Acknowledgements</a></li>
  </ol>
</details>



<!-- ABOUT THE PROJECT -->
## About The Project

I always wanted to know how Regular Expressions worked. That took me down this deep rabbit hole of Formal Grammar, Chomsky Hierarchy, Kleene Star and etc.

I also had been learning Haskell at the time and the concept of Finite State Machine came up time and again. It turns out I can utilize FSA to implement Regex Engines. So I did.

<!-- GETTING STARTED -->
## Getting Started

Install through your favorite package manager to get started.

### Installation

   ```sh
   npm install @rux12/t_rex
   ```
   ```sh
   yarn add @rux12/t_rex
   ```

<!-- USAGE EXAMPLES -->
## Usage
Basic Usage:
```ts
import {build} from "@rux12/t_rex";

const re = build("/(ab|cd)/");

re.matches("ab") // true
re.matches("cd") // true
re.matches("ef") // false
```
You could also use the builders provided.
```ts
import {char, or} from "@rux12/t_rex";

const re = or(
	char("a"),
	char("b")
);

re.matches("a") // true
re.matches("b") // true
re.matches("e") // false
```

<!-- ROADMAP -->
## Roadmap

- [ ] Add Wildcard Support (for now)


<!-- CONTACT -->
## Contact

Email:  rux12@icloud.com

Project Link: [https://github.com/Sangi-it/t_rex](https://github.com/Sang-it/t_rex)

<!-- ACKNOWLEDGMENTS -->
## Acknowledgments

* [regex-tree](https://github.com/DmitrySoshnikov/regexp-tree)