open-index/open-npm huggingface dataset:
npm package: @peleicht/tf2-schema
Description: Modernized TF2 Schema to get information about items, effects, skins and more
Author: Brom127
Latest version: 2.0.13

# node-tf2-schema

Get information about TF2 items, effects, skins and more

Modernized by Brom127 to use Typescript, Classes and async/await Promises.

Includes Typescript types for the Schema and items (except items_game, for now).

Attempts to maintain compatibility with the original node-tf2-schema. The logic and most methods remain the same, though callbacks have entirely been replaced with Promises.
npm package: @peleke.s/buildlog
Description: Engineering notebook for AI-assisted development. Capture your work as publishable content.
Latest version: 0.23.0

# buildlog

Engineering notebook for AI-assisted development. Capture your work as publishable content. Include the fuckups.

This is the npm wrapper for [buildlog](https://github.com/Peleke/buildlog-template). It lets you use buildlog via `npx`/`bunx` in TypeScript and JavaScript projects.

## Quick start

```bash
npx @peleke.s/buildlog init
npx @peleke.s/buildlog new my-feature
npx @peleke.s/buildlog commit -m "feat: add auth"
npx @peleke.s/buildlog skills
npx @peleke.s/buildlog gauntlet loop src/
```

## Install

```bash
# One-off (no install needed)
npx @peleke.s/buildlog init

# Pin as dev dependency
npm install -D buildlog
# or
bun add -D buildlog
```

## Requirements

Python 3.10+ must be available. The npm package is a thin wrapper that invokes the Python CLI.

If `buildlog` isn't already installed, the wrapper will try `uvx buildlog` (auto-downloads from PyPI) or `python -m buildlog` as fallbacks.

To install the Python CLI directly:

```bash
pip install buildlog
# or
uv tool install buildlog
```

## How it works

The npm package ships a single bin shim that:

1. Looks for `buildlog` on PATH
2. Falls back to `uvx buildlog` (zero-install via uv)
3. Falls back to `python3 -m buildlog`
4. Passes through all arguments and stdio transparently

Every command works identically to the Python CLI. See the [full documentation](https://github.com/Peleke/buildlog-template) for details.

## package.json scripts

```json
{
  "scripts": {
    "gauntlet": "buildlog gauntlet loop src/",
    "buildlog:commit": "buildlog commit"
  }
}
```

## License

MIT
npm package: @peleke.s/cadence
Description: Typed event infrastructure for ambient AI agency
Author: Peleke Sengstacke
Latest version: 0.1.0

# Cadence

**Typed event infrastructure for ambient AI agency.**

Cadence is the nervous system for AI agents that watch, notice, and act without being asked. It provides a lightweight, typed pub/sub bus with pluggable transports, persistence, and execution strategies.

## The Problem

Most AI agents are request-response: you ask, they answer. But staff members don't wait to be asked — they notice things and bring them to you.

Cadence closes that gap. It enables **ambient agency**: agents that observe file changes, webhook events, scheduled triggers, and act autonomously based on what they see.

## Installation

```bash
npm install @pelekes/cadence
# or
pnpm add @pelekes/cadence
```

## Quick Start

```typescript
import { createSignalBus, defineSignals, createFileWatcherSource } from "@pelekes/cadence";

// Define your signal types
type MySignals = DefineSignals<{
  "file.changed": { path: string; event: "add" | "change" | "unlink" };
  "task.found": { file: string; task: string; done: boolean };
}>;

// Create a bus
const bus = createSignalBus<MySignals>();

// Subscribe to signals
bus.on("file.changed", async (signal) => {
  console.log(`File ${signal.payload.event}: ${signal.payload.path}`);
});

// Create a source
const watcher = createFileWatcherSource<MySignals>({
  paths: ["./notes"],
  toSignal: (event) => ({
    type: "file.changed",
    ts: Date.now(),
    id: crypto.randomUUID(),
    payload: { path: event.path, event: event.type },
  }),
});

// Start watching
await watcher.start(bus);
```

## Architecture

Cadence is built with pluggable interfaces:

- **Transport** — How signals move (in-memory, Redis, HTTP bridge)
- **Store** — Durability layer (none, SQLite, Redis)
- **Executor** — Handler concurrency (sequential, concurrent with limits)

Build for the sophisticated case, implement simple defaults.

## Use Cases

- **Ambient Obsidian agent** — Watch your vault, extract tasks, act on them
- **PR delegate** — Watch journals, cluster insights, draft social posts
- **Proactive pair programmer** — Watch code changes, surface forgotten TODOs
- **Multi-agent coordination** — Agents communicate via signal emission

## License

MIT
npm package: @pelevesque/are-substrings-over-maximum-density
Description: Checks if substrings are over maximum densities in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.5

[![Build Status](https://travis-ci.org/pelevesque/are-substrings-over-maximum-density.svg?branch=master)](https://travis-ci.org/pelevesque/are-substrings-over-maximum-density)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/are-substrings-over-maximum-density/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/are-substrings-over-maximum-density?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# are-substrings-over-maximum-density

Checks if substrings are over maximum densities in a string.

## Related Packages

https://github.com/pelevesque/are-substrings-under-minimum-density  
https://github.com/pelevesque/are-substrings-over-maximum-occurrences  
https://github.com/pelevesque/are-substrings-under-minimum-occurrences  

## Node Repository

https://www.npmjs.com/package/@pelevesque/are-substrings-over-maximum-density

## Installation

`npm install @pelevesque/are-substrings-over-maximum-density`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Requiring

```js
const areSubstringsOverMaximumDensity = require('@pelevesque/are-substrings-over-maximum-density')
```

### One Check

```js
// over density returns true
// 'a' takes up 50% of the string, more than a 25% density
const str = 'aaaabbbb'
const checks = { a: 0.25 }
const result = areSubstringsOverMaximumDensity(str, checks)
// result === true
```

```js
// equal to density returns false
const str = 'aaaabbbb'
const checks = { a: 0.5 }
const result = areSubstringsOverMaximumDensity(str, checks)
// result === false
```

```js
// under density returns false
const str = 'a man, a hog, and a fly'
const checks = { hog: 0.5 }
const result = areSubstringsOverMaximumDensity(str, checks)
// result === false
```

### Multiple Checks

```js
// when one is over density, it returns true ('a' is over 25%)
const str = 'aaaabbbb'
const checks = { a: 0.25, b: 0.5, c: 0.3 }
const result = areSubstringsOverMaximumDensity(str, checks)
// result === true
```

```js
// when all are under or equal to density, it returns false
const str = 'a man, a hog, and a fly'
const checks = { a: 0.5, hog: 0.5, c: 0.3 }
const result = areSubstringsOverMaximumDensity(str, checks)
// result === false
```
npm package: @pelevesque/are-substrings-over-maximum-occurrences
Description: Checks if substrings are over maximum occurrences in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.5

[![Build Status](https://travis-ci.org/pelevesque/are-substrings-over-maximum-occurrences.svg?branch=master)](https://travis-ci.org/pelevesque/are-substrings-over-maximum-occurrences)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/are-substrings-over-maximum-occurrences/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/are-substrings-over-maximum-occurrences?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# are-substrings-over-maximum-occurrences

Checks if substrings are over maximum occurrences in a string.

## Related Packages

https://github.com/pelevesque/are-substrings-under-minimum-occurrences  
https://github.com/pelevesque/are-substrings-over-maximum-density   
https://github.com/pelevesque/are-substrings-under-minimum-density  

## Node Repository

https://www.npmjs.com/package/@pelevesque/are-substrings-over-maximum-occurrences

## Installation

`npm install @pelevesque/are-substrings-over-maximum-occurrences`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Requiring

```js
const areSubstringsOverMaximumOccurrences = require('@pelevesque/are-substrings-over-maximum-occurrences')
```

### One Check

```js
// over occurrences returns true
// 'a' has 4 occurrences, more than the specified limit of 2
const str = 'aaaabbbb'
const checks = { a: 2 }
const result = areSubstringsOverMaximumOccurrences(str, checks)
// result === true
```

```js
// equal to occurrences returns false
const str = 'aaaabbbb'
const checks = { a: 4 }
const result = areSubstringsOverMaximumOccurrences(str, checks)
// result === false
```

```js
// under occurrences returns false
const str = 'a man, a hog, and another hog'
const checks = { hog: 1 }
const result = areSubstringsOverMaximumOccurrences(str, checks)
// result === false
```

### Multiple Checks

```js
// when one is over occurrences, it returns true ('a' is over 2)
const str = 'aaaabbbb'
const checks = { a: 2, b: 8, c: 2 }
const result = areSubstringsOverMaximumOccurrences(str, checks)
// result === true
```

```js
// when all are under or equal to occurrences, it returns false
const str = 'a man, a hog, and another hog'
const checks = { a: 8, hog: 8, c: 8 }
const result = areSubstringsOverMaximumOccurrences(str, checks)
// result === false
```
npm package: @pelevesque/are-substrings-under-minimum-density
Description: Checks if substrings are under minimum densities in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.5

[![Build Status](https://travis-ci.org/pelevesque/are-substrings-under-minimum-density.svg?branch=master)](https://travis-ci.org/pelevesque/are-substrings-under-minimum-density)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/are-substrings-under-minimum-density/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/are-substrings-under-minimum-density?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# are-substrings-under-minimum-density

Checks if substrings are under minimum densities in a string.

## Related Packages

https://github.com/pelevesque/are-substrings-over-maximum-density   
https://github.com/pelevesque/are-substrings-under-minimum-occurrences  
https://github.com/pelevesque/are-substrings-over-maximum-occurrences  

## Node Repository

https://www.npmjs.com/package/@pelevesque/are-substrings-under-minimum-density

## Installation

`npm install @pelevesque/are-substrings-under-minimum-density`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Requiring

```js
const areSubstringsUnderMinimumDensity = require('@pelevesque/are-substrings-under-minimum-density')
```

### One Check

```js
// under density returns true
// 'a' takes up 50% of the string, less than a 75% density
const str = 'aaaabbbb'
const checks = { a: 0.75 }
const result = areSubstringsUnderMinimumDensity(str, checks)
// result === true
```

```js
// equal to density returns false
const str = 'aaaabbbb'
const checks = { a: 0.5 }
const result = areSubstringsUnderMinimumDensity(str, checks)
// result === false
```

```js
// over density returns false
const str = 'a man, a hog, and a fly'
const checks = { hog: 0.01 }
const result = areSubstringsUnderMinimumDensity(str, checks)
// result === false
```

### Multiple Checks

```js
// when one is under density, it returns true ('a' is under 75%)
const str = 'aaaabbbb'
const checks = { a: 0.75, b: 0.5 }
const result = areSubstringsUnderMinimumDensity(str, checks)
// result === true
```

```js
// when all are over or equal to density, it returns false
const str = 'aaaabbbb'
const checks = { a: 0.25, bbbb: 0.5 }
const result = areSubstringsUnderMinimumDensity(str, checks)
// result === false
```
npm package: @pelevesque/are-substrings-under-minimum-occurrences
Description: Checks if substrings are under minimum occurrences in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.5

[![Build Status](https://travis-ci.org/pelevesque/are-substrings-under-minimum-occurrences.svg?branch=master)](https://travis-ci.org/pelevesque/are-substrings-under-minimum-occurrences)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/are-substrings-under-minimum-occurrences/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/are-substrings-under-minimum-occurrences?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# are-substrings-under-minimum-occurrences

Checks if substrings are under minimum occurrences in a string.

## Related Packages

https://github.com/pelevesque/are-substrings-over-maximum-occurrences  
https://github.com/pelevesque/are-substrings-under-minimum-density  
https://github.com/pelevesque/are-substrings-over-maximum-density  

## Node Repository

https://www.npmjs.com/package/@pelevesque/are-substrings-under-minimum-occurrences

## Installation

`npm install @pelevesque/are-substrings-under-minimum-occurrences`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Requiring

```js
const areSubstringsUnderMinimumOccurrences = require('@pelevesque/are-substrings-under-minimum-occurrences')
```

### One Check

```js
// under occurrences returns true
// 'a' has 4 occurrences, less than 8
const str = 'aaaabbbb'
const checks = { a: 8 }
const result = areSubstringsUnderMinimumOccurrences(str, checks)
// result === true
```

```js
// equal to occurrences returns false
const str = 'aaaabbbb'
const checks = { a: 4 }
const result = areSubstringsUnderMinimumOccurrences(str, checks)
// result === false
```

```js
// over occurrences returns false
const str = 'a man, a hog, and another hog'
const checks = { hog: 1 }
const result = areSubstringsUnderMinimumOccurrences(str, checks)
// result === false
```

### Multiple Checks

```js
// when one is under occurrences, it returns true ('a' is under 8)
const str = 'aaaabbbb'
const checks = { a: 8, b: 4 }
const result = areSubstringsUnderMinimumOccurrences(str, checks)
// result === true
```

```js
// when all are over or equal to occurrences, it returns false
const str = 'a man, a hog, and another hog'
const checks = { a: 1, hog: 1 }
const result = areSubstringsUnderMinimumOccurrences(str, checks)
// result === false
```
npm package: @pelevesque/canonicalize-string
Description: Canonicalizes a UTF-8 string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.6

[![Build Status](https://travis-ci.org/pelevesque/canonicalize-string.svg?branch=master)](https://travis-ci.org/pelevesque/canonicalize-string)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/canonicalize-string/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/canonicalize-string?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# canonicalize-string

Canonicalizes a UTF-8 string.

canonicalize-string converts a string to lowercase, removes diacritics, then
removes homoglyphs including graphemes.

## Node Repository

https://www.npmjs.com/package/@pelevesque/canonicalize-string

## Installation

`npm install @pelevesque/canonicalize-string`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const canonicalizeString = require('@pelevesque/canonicalize-string')
```

```js
const str = 'AmwÉ'
const result = canonicalizeString(str)
// result === arnwe
```
npm package: @pelevesque/change-number-base
Description: Converts a number from one base to another.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.5

[![Build Status](https://travis-ci.org/pelevesque/change-number-base.svg?branch=master)](https://travis-ci.org/pelevesque/change-number-base)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/change-number-base/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/change-number-base?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# change-number-base

Converts a number from one base to another.

## Node Repository

https://www.npmjs.com/package/@pelevesque/change-number-base

## Installation

`npm install @pelevesque/change-number-base`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const changeNumberBase = require('@pelevesque/change-number-base')
```

```js
const num = 102
const initialBase = 3
const newBase = 10
const result = changeNumberBase(num, initialBase, newBase)
// result === 11
```
npm package: @pelevesque/clone-array-of-arrays
Description: Clones an array of arrays.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.7

[![Build Status](https://travis-ci.org/pelevesque/clone-array-of-arrays.svg?branch=master)](https://travis-ci.org/pelevesque/clone-array-of-arrays)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/clone-array-of-arrays/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/clone-array-of-arrays?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# clone-array-of-arrays

Clones an array of arrays.

## Node Repository

https://www.npmjs.com/package/@pelevesque/clone-array-of-arrays

## Installation

`npm install @pelevesque/clone-array-of-arrays`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const cloneArrayOfArrays = require('@pelevesque/clone-array-of-arrays')
```

```js
const arrayOfArrays = [[0, 0], [0, 1], [0, 2]]
const result = cloneArrayOfArrays(arrayOfArrays)
// result === [[0, 0], [0, 1], [0, 2]]
```
npm package: @pelevesque/find-char
Description: Finds all the indices of a char in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.1.2

[![Build Status](https://travis-ci.org/pelevesque/find-char.svg?branch=master)](https://travis-ci.org/pelevesque/find-char)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/find-char/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/find-char?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# find-char

Finds all the indices of a char in a string.

## Node Repository

https://www.npmjs.com/package/@pelevesque/find-char

## Installation

`npm install @pelevesque/find-char`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

## Usage

find-char returns an array of all the indices of the char in the string.

If the char is not found, -1 is returned.

```js
const findChar = require('@pelevesque/find-char')
const str = 'a little rabbit and an oxe'
const char = 'a'
const result = findChar(str, char)
// result === [0, 10, 16, 20]
```
npm package: @pelevesque/find-duplicates
Description: Finds indices of duplicates in an array of elements.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.1.1

[![Build Status](https://travis-ci.org/pelevesque/find-duplicates.svg?branch=master)](https://travis-ci.org/pelevesque/find-duplicates)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/find-duplicates/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/find-duplicates?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# find-duplicates

Finds indices of duplicates in an array of elements.

find-duplicates uses lodash.isequal to make comparisons, so any type supported by lodash.isequal is supported by find-duplicates.

## Node Repository

[https://www.npmjs.com/package/@pelevesque/find-duplicates](https://www.npmjs.com/package/@pelevesque/find-duplicates)

## Installation

`npm install @pelevesque/find-duplicates`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

### Usage

#### Requiring the Module

```js
const findDuplicates = require('@pelevesque/find-duplicates')
```

#### One Set of Duplicates

```js
const elements = [
  'd131dd02c5e6eec4', // a
  '55ad340609f4b302',
  'd131dd02c5e6eec4', // a
  'd131dd02c5e6eec4', // a
  'd8823e3156348f5b'
]
const result = findDuplicates(elements)
// result === [[0, 2, 3]]
```

#### Many Sets of Duplicates

```js
const elements = [
  'd131dd02c5e6eec4', // a
  '55ad340609f4b302',
  'd8823e3156348f5b', // b
  'd131dd02c5e6eec4', // a
  'd8823e3156348f5b', // b
  '551111111114b302', // c
  '551111111114b302'  // c
]
const result = findDuplicates(elements)
// result === [[0, 3], [2, 4], [5, 6]]
```

#### Using the stopAtFirstSet Flag

```js
// When using the stopAtFirstSet flag, only the first set is returned.
// Note: In this case, an array is returned instead of an array of arrays.
const elements = [
  'd131dd02c5e6eec4', // a
  '55ad340609f4b302',
  'd8823e3156348f5b', // b
  'd131dd02c5e6eec4', // a
  'd8823e3156348f5b', // b
  '551111111114b302', // c
  '551111111114b302'  // c
]
const stopAtFirstSet = true
const result = findDuplicates(elements, stopAtFirstSet)
// result === [0, 3]
```
npm package: @pelevesque/find-indexes-of-duplicates
Description: Finds indexes of duplicates in an array of elements.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.2

[![Build Status](https://travis-ci.org/pelevesque/find-indexes-of-duplicates.svg?branch=master)](https://travis-ci.org/pelevesque/find-indexes-of-duplicates)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/find-indexes-of-duplicates/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/find-indexes-of-duplicates?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# find-indexes-of-duplicates

Finds indexes of duplicates in an array of elements.

`find-indexes-of-duplicates` uses `lodash.isequal` to make comparisons, so any
type supported by `lodash.isequal` is supported by `find-indexes-of-duplicates`.

## Node Repository

https://www.npmjs.com/package/@pelevesque/find-indexes-of-duplicates

## Installation

`npm install @pelevesque/find-indexes-of-duplicates`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

### Usage

#### Requiring

```js
const findIndexesOfDuplicates = require('@pelevesque/find-indexes-of-duplicates')
```

#### One Set of Duplicates

```js
const elements = [
  'd131dd02c5e6eec4', // a
  '55ad340609f4b302',
  'd131dd02c5e6eec4', // a
  'd131dd02c5e6eec4', // a
  'd8823e3156348f5b'
]
const result = findIndexesOfDuplicates(elements)
// result === [[0, 2, 3]]
```

#### Many Sets of Duplicates

```js
const elements = [
  'd131dd02c5e6eec4', // a
  '55ad340609f4b302',
  'd8823e3156348f5b', // b
  'd131dd02c5e6eec4', // a
  'd8823e3156348f5b', // b
  '551111111114b302', // c
  '551111111114b302'  // c
]
const result = findIndexesOfDuplicates(elements)
// result === [[0, 3], [2, 4], [5, 6]]
```

#### Using the stopAtFirstSet Flag

```js
// When using the stopAtFirstSet flag, only the first set is returned.
// Note: In this case, an array is returned instead of an array of arrays.
const elements = [
  'd131dd02c5e6eec4', // a
  '55ad340609f4b302',
  'd8823e3156348f5b', // b
  'd131dd02c5e6eec4', // a
  'd8823e3156348f5b', // b
  '551111111114b302', // c
  '551111111114b302'  // c
]
const stopAtFirstSet = true
const result = findIndexesOfDuplicates(elements, stopAtFirstSet)
// result === [0, 3]
```
npm package: @pelevesque/find-nearest-number
Description: Finds the nearest number of a given target number.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.4

[![Build Status](https://travis-ci.org/pelevesque/find-nearest-number.svg?branch=master)](https://travis-ci.org/pelevesque/find-nearest-number)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/find-nearest-number/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/find-nearest-number?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# find-nearest-number

Finds the nearest number of a given target number.

## Node Repository

https://www.npmjs.com/package/@pelevesque/find-nearest-number

## Installation

`npm install @pelevesque/find-nearest-number`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const findNearestNumber = require('@pelevesque/find-nearest-number')
```

```js
const num = 45
const arr = [-100, -50, 0, 50, 100]
const result = findNearestNumber(num, arr)
// result === 50
```
npm package: @pelevesque/find-substring-indexes
Description: Finds all the indexes of a substring.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.1

[![Build Status](https://travis-ci.org/pelevesque/find-substring-indexes.svg?branch=master)](https://travis-ci.org/pelevesque/find-substring-indexes)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/find-substring-indexes/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/find-substring-indexes?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# find-substring-indexes

Finds all the indexes of a substring.

## Node Repository

https://www.npmjs.com/package/@pelevesque/find-substring-indexes

## Installation

`npm install @pelevesque/find-substring-indexes`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

## Usage

`find-substring-indexes` returns an array of all the indexes of the substring.

```js
const findSubstringIndexes = require('@pelevesque/find-substring-indexes')
```

```js
const str = 'a little cat and a hat'
const substring = 'a'
const result = findSubstringIndexes(str, substring)
// result === [0, 10, 13, 17, 20]
```

```js
const str = 'at a cat and a brat with a hat'
const substring = 'at'
const result = findSubstringIndexes(str, substring)
// result === [0, 6, 17, 28]
```
npm package: @pelevesque/get-matrix-dihedral-group
Description: Gets all the variants for a matrix dihedral group.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.4

[![Build Status](https://travis-ci.org/pelevesque/get-matrix-dihedral-group.svg?branch=master)](https://travis-ci.org/pelevesque/get-matrix-dihedral-group)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/get-matrix-dihedral-group/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/get-matrix-dihedral-group?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# get-matrix-dihedral-group

Gets all the variants of a matrix dihedral group.

## Node Repository

https://www.npmjs.com/package/@pelevesque/get-matrix-dihedral-group

## Installation

`npm install @pelevesque/get-matrix-dihedral-group`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

## Usage

### Requiring

```js
const getMatrixDihedralGroup = require('@pelevesque/get-matrix-dihedral-group')
```

### Retrieving the Matrix Dihedral Group

```js
const matrix = [
  [1, 1, 1],
  [0, 0, 0],
  [0, 0, 0]
]
const result = getMatrixDihedralGroup(matrix)
// result is now equal to the array below
result = [
  [ [ 1, 1, 1 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ],
  [ [ 0, 0, 1 ], [ 0, 0, 1 ], [ 0, 0, 1 ] ],
  [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 1, 1, 1 ] ],
  [ [ 1, 0, 0 ], [ 1, 0, 0 ], [ 1, 0, 0 ] ],
  [ [ 1, 1, 1 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ],
  [ [ 1, 0, 0 ], [ 1, 0, 0 ], [ 1, 0, 0 ] ],
  [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 1, 1, 1 ] ],
  [ [ 0, 0, 1 ], [ 0, 0, 1 ], [ 0, 0, 1 ] ]
]
```

In the example above, some elements of the group are identical because there is symmetry in the original element.

Duplicate elements can be removed by turning on the `removeDuplicates` flag as in the example below.

```js
const matrix = [
  [1, 1, 1],
  [0, 0, 0],
  [0, 0, 0]
]
const removeDuplicates = true
const result = getMatrixDihedralGroup(matrix, removeDuplicates)
// result is now equal to the array below
result = [
  [ [ 1, 1, 1 ], [ 0, 0, 0 ], [ 0, 0, 0 ] ],
  [ [ 0, 0, 1 ], [ 0, 0, 1 ], [ 0, 0, 1 ] ],
  [ [ 0, 0, 0 ], [ 0, 0, 0 ], [ 1, 1, 1 ] ],
  [ [ 1, 0, 0 ], [ 1, 0, 0 ], [ 1, 0, 0 ] ]
]
```
npm package: @pelevesque/hash-code
Description: A JavaScript implementation of Java's hashCode method.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.6

[![Build Status](https://travis-ci.org/pelevesque/hash-code.svg?branch=master)](https://travis-ci.org/pelevesque/hash-code)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/hash-code/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/hash-code?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# hash-code

A JavaScript implementation of Java's hashCode method.

## Node Repository

https://www.npmjs.com/package/@pelevesque/hash-code

## Installation

`npm install @pelevesque/hash-code`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const hashCode = require('@pelevesque/hash-code')
```

```js
const result = hashCode('rabbit')
// result === -938645478
```
npm package: @pelevesque/have-minimum-density
Description: Checks if substrings have a minimum density in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.5

[![Build Status](https://travis-ci.org/pelevesque/have-minimum-density.svg?branch=master)](https://travis-ci.org/pelevesque/have-minimum-density)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/have-minimum-density/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/have-minimum-density?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# have-minimum-density

Checks if substrings have a minimum density in a string.

@see https://www.npmjs.com/package/@pelevesque/have-minimum-occurrences for minimum occurrences.

## Node Repository

https://www.npmjs.com/package/@pelevesque/have-minimum-density

## Installation

`npm install @pelevesque/have-minimum-density`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

## Usage

```js
const haveMinimumDensity = require('@pelevesque/have-minimum-density')
```

```js
const str = 'aaaabbbb'
const checks = [['a', 0.5]]
const result = haveMinimumDensity(str, checks)
// result === true
```

```js
const str = 'aaaabbbb'
const checks = [['a', 0.8]]
const result = haveMinimumDensity(str, checks)
// result === false
```

```js
const str = 'aaaabbbbccccdddd'
const checks = [['a', 0.25], ['?', 0.1], ['b', 0.5]]
const result = haveMinimumDensity(str, checks)
// result === false
```

```js
const str = 'aaaabbbbccccdddd'
const checks = [['a', 0.1], ['b', 0.25], ['c', 0.05], ['d', 0.02]]
const result = haveMinimumDensity(str, checks)
// result === true
```

```js
const str = 'aabaacaabaad'
const checks = [['aab', 0.5]]
const result = haveMinimumDensity(str, checks)
// result === true
```
npm package: @pelevesque/have-minimum-occurrences
Description: Checks if substrings occur a minimum number of times in a string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.4

[![Build Status](https://travis-ci.org/pelevesque/have-minimum-occurrences.svg?branch=master)](https://travis-ci.org/pelevesque/have-minimum-occurrences)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/have-minimum-occurrences/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/have-minimum-occurrences?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# have-minimum-occurrences

Checks if substrings occur a minimum number of times in a string.

@see https://www.npmjs.com/package/@pelevesque/have-minimum-density for minimum density.

## Node Repository

https://www.npmjs.com/package/@pelevesque/have-minimum-occurrences

## Installation

`npm install @pelevesque/have-minimum-occurrences`

## Tests

### Standard Style & Unit Tests

`npm test`

### Unit Tests & Coverage

`npm run cover`

## Usage

```js
const haveMinimumOccurrences = require('@pelevesque/have-minimum-occurrences')
```

```js
const str = 'A little string.'
const checks = [['i', 2]]
const result = haveMinimumOccurrences(str, checks)
// result === true
```

```js
const str = 'A little string.'
const checks = [['i', 3]]
const result = haveMinimumOccurrences(str, checks)
// result === false
```

```js
const str = 'A little string.'
const checks = [['i', 2], ['t', 3], [' ', 2]]
const result = haveMinimumOccurrences(str, checks)
// result === true
```

```js
const str = 'A little string.'
const checks = [['i', 5], ['t', 3], [' ', 2]]
const result = haveMinimumOccurrences(str, checks)
// result === false
```

```js
const str = 'aab111111aab'
const checks = [['aab', 2]]
const result = haveMinimumOccurrences(str, checks)
// result === true
```
npm package: @pelevesque/insert-string
Description: Inserts a string inside another string.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.6

[![Build Status](https://travis-ci.org/pelevesque/insert-string.svg?branch=master)](https://travis-ci.org/pelevesque/insert-string)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/insert-string/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/insert-string?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# insert-string

Inserts a string inside another string.

## Node Repository

https://www.npmjs.com/package/@pelevesque/insert-string

## Installation

`npm install @pelevesque/insert-string`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Requiring the Module

```js
const insertString = require('@pelevesque/insert-string')
```
### Insertion

```js
const str = 'I have an apple.'
const insert = 'an orange and '
const index = 7
const result = insertString(str, insert, index)
// result === 'I have an orange and an apple.'
```

### Substitution

The fourth parameter `numCharsToRemove` defaults to `0` which permits inserts.

To make a substitution, setting `numCharsToRemove` to `-1` will give it the same
length as the string to insert.

```js
const str = 'A nice guy.'
const insert = 'cool'
const index = 2
const numCharsToRemove = -1
const result = insertString(str, insert, index, numCharsToRemove)
// result === 'A cool guy.'
```

### Irregular Substitution

By explicitly setting `numCharsToRemove` to the number of characters to
remove, it's possible to do substitutions where the string to insert does not
have the same length as the string that it is replacing.

```js
const str = 'My name is Jack Black and I act.'
const insert = 'Joe'
const index = 11
const numCharsToRemove = 10 // the length of 'Jack Black'
const result = insertString(str, insert, index, numCharsToRemove)
// result === 'My name is Joe and I act.'
```

### A Substitution Using a Negative Index

You can use a negative index to add the insert before the original string.

```js
const str = 'abc'
const substitution = '012'
const index = -3
const result = insertString(str, insert, index)
// result === '012abc'
```
npm package: @pelevesque/interlace-strings
Description: Interlaces strings together.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.4

[![Build Status](https://travis-ci.org/pelevesque/interlace-strings.svg?branch=master)](https://travis-ci.org/pelevesque/interlace-strings)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/interlace-strings/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/interlace-strings?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# interlace-strings

Interlaces strings together.

## Node Repository

https://www.npmjs.com/package/@pelevesque/interlace-strings

## Installation

`npm install @pelevesque/interlace-strings`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const interlaceStrings = require('@pelevesque/interlace-strings')
```

```js
const str1 = '12345'
const str2 = 'abcde'
const arrayOfStrings = [str1, str2]
const result = interlaceStrings(arrayOfStrings)
// result === 1a2b3c4d5e
```

```js
const str1 = '12345678'
const str2 = 'abcdef'
const str3 = '!@#$'
const str4 = '_-'
const arrayOfStrings = [str1, str2, str3, str4]
const result = interlaceStrings(arrayOfStrings)
// result === 1a!_2b@-3c#4d$5e6f78
```
npm package: @pelevesque/is-array-in-array
Description: Checks if an array is in an array.
Author: Pierre-Emmanuel Lévesque
Latest version: 1.0.2

[![Build Status](https://travis-ci.org/pelevesque/is-array-in-array.svg?branch=master)](https://travis-ci.org/pelevesque/is-array-in-array)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/is-array-in-array/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/is-array-in-array?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# is-array-in-array

Checks if an array is in an array.

## Node Repository

https://www.npmjs.com/package/@pelevesque/is-array-in-array

## Installation

`npm install @pelevesque/is-array-in-array`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const isArrayInArray = require('@pelevesque/is-array-in-array')
```

```js
const arr = [1, 1]
const arrToCheckIn = [[1, 0], [1, 1], [1, 2]]
const result = isArrayInArray(arr, arrToCheckIn)
// result === true
```
npm package: @pelevesque/is-offset
Description: Checks if a string is the offset of another.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.8

[![Build Status](https://travis-ci.org/pelevesque/is-offset.svg?branch=master)](https://travis-ci.org/pelevesque/is-offset)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/is-offset/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/is-offset?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# is-offset

Checks if a string is the offset of another.

## Node Repository

https://www.npmjs.com/package/@pelevesque/is-offset

## Installation

`npm install @pelevesque/is-offset`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Parameters

```js
str1 (required)  
str2 (required)   
step (optional) default = 1
```

### Examples

```js
const isOffset = require('@pelevesque/is-offset')
```

```js
const str1 = 'abcd'
const str2 = 'efgh'
const result = isOffset(str1, str2)
// result === false
```

```js
const str1 = 'abcd'
const str2 = 'bcda'
const result = isOffset(str1, str2)
// result === true
```

```js
const str1 = '111222333444'
const str2 = '333444111222'
const step = 3
const result = isOffset(str1, str2, step)
// result === true
```
npm package: @pelevesque/is-palindrome
Description: Checks if a string is a palindrome with a grouping feature not seen in other palindrome checkers.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.8

[![Build Status](https://travis-ci.org/pelevesque/is-palindrome.svg?branch=master)](https://travis-ci.org/pelevesque/is-palindrome)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/is-palindrome/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/is-palindrome?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# is-palindrome

Checks if a string is a palindrome with a grouping feature not seen in other palindrome checkers.

## Node Repository

https://www.npmjs.com/package/@pelevesque/is-palindrome

## Installation

`npm install @pelevesque/is-palindrome`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

### Parameters

```js
str                    (required)
groupBy                (optional) default = 1
pivotMustBePalindromic (optional) default = false
```

### Examples

```js
const isPalindrome = require('@pelevesque/is-palindrome')
```

```js
// works with traditional palindromes
isPalindrome('')      // false
isPalindrome('12345') // false
isPalindrome('a')     // true
isPalindrome('1221')  // true
isPalindrome('12321') // true
```

```js
// a groupBy parameter can be used to group elements
const groupBy = 2
isPalindrome('abba',  groupBy) // false
isPalindrome('abab',  groupBy) // true
isPalindrome('abcba', groupBy) // true

// pivots do not have to be palindromic by default
// they exist when a center point is smaller than groupBy * 2
const groupBy = 4
isPalindrome('abcd!@#$123!@#$abcd',   groupBy) // true
isPalindrome('abcd!@#$1234!@#$abcd',  groupBy) // true
isPalindrome('abcd!@#$12345!@#$abcd', groupBy) // true
isPalindrome('abcd!@#$12321!@#$abcd', groupBy) // true
```

```js
// the pivotMustBePalindromic flag can be used to force palindromic pivots
const groupBy = 4
const pivotMustBePalindromic = true
isPalindrome('abcd!@#$12345!@#$abcd', groupBy, pivotMustBePalindromic) // false
isPalindrome('abcd!@#$12321!@#$abcd', groupBy, pivotMustBePalindromic) // true
```
npm package: @pelevesque/is-point-in
Description: Checks if a point is inside a shape.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.1.4

[![Build Status](https://travis-ci.org/pelevesque/is-point-in.svg?branch=master)](https://travis-ci.org/pelevesque/is-point-in)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/is-point-in/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/is-point-in?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# is-point-in

Checks if a point is inside a shape.

## Node Repository

https://www.npmjs.com/package/@pelevesque/is-point-in

## Installation

`npm install @pelevesque/is-point-in`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Methods

- `rectangle` Checks if a point is inside a rectangle.
- `circle` Checks if a point is inside a circle.

## Usage

### Initialization

#### Requiring the Entire Module

```js
const IsPointIn = require('@pelevesque/is-point-in')
```

#### Requiring a Specific Method

```js
const IsPointInRectangle = require('@pelevesque/is-point-in').rectangle
```

### Rectangle

```js
// point
const x = 10
const y = 10

// rectangle
const x1 = 5
const y1 = 5
const x2 = 15
const y2 = 15

const result = IsPointIn.rectangle(x, y, x1, y1, x2, y2)
// result === true
```

### Circle

```js
// point
const x = -3.84
const y = 3.22

// circle
const cx = 0
const cy = 0
const cRadius = 5

const result = IsPointIn.circle(x, y, cx, cy, cRadius)
// result === false
```
npm package: @pelevesque/make-grid
Description: Creates a two dimensional array arranged as a grid with `x`, `y`, `w`, `h` values on each item.
Author: Pierre-Emmanuel Lévesque
Latest version: 0.0.9

[![Build Status](https://travis-ci.org/pelevesque/make-grid.svg?branch=master)](https://travis-ci.org/pelevesque/make-grid)
[![Coverage Status](https://coveralls.io/repos/github/pelevesque/make-grid/badge.svg?branch=master)](https://coveralls.io/github/pelevesque/make-grid?branch=master)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)

# make-grid

Creates a two dimensional array arranged as a grid with `x`, `y`, `w`, `h` values on each item.

## Node Repository

https://www.npmjs.com/package/@pelevesque/make-grid

## Installation

`npm install @pelevesque/make-grid`

## Tests

Command                      | Description
---------------------------- | ------------
`npm test` or `npm run test` | All Tests Below
`npm run cover`              | Standard Style
`npm run standard`           | Coverage
`npm run unit`               | Unit Tests

## Usage

```js
const makeGrid = require('@pelevesque/make-grid')
```

```js
const numRows = 3
const numCols = 5
const cellWidth = 2
const cellHeight = 3
const grid = makeGrid(numRows, numCols, cellWidth, cellHeight)

// result
grid = [
  [ { x: 0, y: 0, w: 2, h: 3 },
    { x: 2, y: 0, w: 2, h: 3 },
    { x: 4, y: 0, w: 2, h: 3 },
    { x: 6, y: 0, w: 2, h: 3 },
    { x: 8, y: 0, w: 2, h: 3 }
  ], [
    { x: 0, y: 3, w: 2, h: 3 },
    { x: 2, y: 3, w: 2, h: 3 },
    { x: 4, y: 3, w: 2, h: 3 },
    { x: 6, y: 3, w: 2, h: 3 },
    { x: 8, y: 3, w: 2, h: 3 }
  ], [
    { x: 0, y: 6, w: 2, h: 3 },
    { x: 2, y: 6, w: 2, h: 3 },
    { x: 4, y: 6, w: 2, h: 3 },
    { x: 6, y: 6, w: 2, h: 3 },
    { x: 8, y: 6, w: 2, h: 3 }
  ]
]
```