open-index/open-npm huggingface dataset:
npm package: @stein197/bw
Description: Easier bitwise operations
Author: Nail' Gafarov
Latest version: 1.0.0

# Easier bitwise operations
This package provides a tiny set of functions to make work with bitmask much easier.

## Installation
```
npm install @stein197/bw
```
Or embed directly in HTML from [release page](releases)

## Usage
The next code chunk illustrates all available functions that the package provides. For more details refer to doc comments in the source code.
```ts
import * as bw from "@stein197/bw";

bw.get(0b1011, 0); // 1: The least significant bit
bw.set(0b1011, 2); // 0b1111: Sets bit at index 2 to 1
bw.unset(0b1011, 1); // 0b1001: Unsets bit at index 1
bw.toggle(0b1011, 0); // 0b1010: Toggles (inverses) bit at index 0
bw.toArray(0b1011); // [1, 1, 0, 1]: Converts number into a bit array
bw.fromArray([1, 1, 0, 1]); // 0b1011: Converts bitarray into a number
```

Note that index counting starts at 0 and goes from right to left. For example bit at 0 index for `0b100` number is 0 and the only 1 in the number can be referred by index 2.

> **NOTE**: For bit arrays the order of bits is reversed. This is done in order to access bits in array in the same manner as for numbers. So bit at index 0 refers to the least significant bit.

# NPM scripts
- `clean` cleans output files
- `build` builds the project
- `test` builds and tests the project
npm package: @stein197/caser
Description: String case converter and parser
Author: Nail' Gafarov
Latest version: 3.1.0

# String case converter and parser
[![](https://img.shields.io/github/license/stein197/js-caser)](LICENSE)
![](https://img.shields.io/npm/v/@stein197/caser)

This tiny package provides means for converting strings between different cases - such as converting `camelCase` to `snake_case` and so on.

## Installation
```
npm install @stein197/caser
```

## Usage:
```ts
import * as caser from "@stein197/caser";

caser.covert("HTMLElement", "header", true); // "HTML-Element"
caser.convert("CONSTANT_VALUE", {separator: "-", leadCharCase: "upper", firstCharCase: "upper", case: "lower"}, false); // "Constant-Value"
caser.split("camelCase"); // ["camel", "Case"]
```

### Predefined cases
- `flat` flatcase
- `camel` camelCase
- `header` Header-Case
- `kebab` kebab-case
- `pascal` PascalCase
- `snake` snake_case
- `upper` UPPER_CASE
- `train` TRAIN-CASE
> For detailed documentation, refer to the source code docblocks

## NPM scripts
- `clean` cleans working directory from compiled files
- `build` compiles source code
- `test` runs unit tests
npm package: @stein197/cli
Description: Command Line Interface utilities
Author: Nail' Gafarov
Latest version: 1.2.0

# Command Line Interface utilities

## Installation
```
npm install @stein197/cli
```

## Usage
```ts
import * as arg from "@stein197/cli/arg";

arg.parse("--opt1 val1 -- str1"); // {args: ["str1"], opts: {opt1: "val1"}}
```

## API
| Module | Functions |
|--------|-----------|
| arg    | parse     |

> NOTE. Please, refer to docblocks in the source code for more detailed documentation.

## npm scripts
- `build` run `clean`, `test` and `ts` scripts
- `clean` delete compiled files
- `test` run tests
- `ts` compile the project
- `ts:check` run compile check
npm package: @stein197/cookie
Description: Tiny JavaScript cookie library
Latest version: 2.0.0

# Tiny JavaScript cookie library
This tiny library provides a simple way for managing cookies in a browser.

## Installation
```
npm install @stein197/cookie
```

## Usage
```ts
import Cookie from "@stein197/cookie";

const cookie = new Cookie(document);
cookie.get("key");                       // Return a value denoted by a key
cookie.get();                            // Return all cookies
cookie.set("key", "value", {path: "/"}); // Set a single value
cookie.set({key: "value"});              // Set multiple values
cookie.has("key");                       // Returns true if there is a value associated with the key
cookie.unset("key");                     // Remove an entry by a key
cookie.clear();                          // Remove all entries
cookie.parse("key=value");               // Parse cookie string
cookie.stringify({key: "value"});        // Stringify an object
// ...
```
### API
> Refer to the source code for the documentation, please

## NPM scripts
- `clean` Deletes compiled files
- `test` Runs unit tests
- `build` Builds the project
npm package: @stein197/css-reset
Description: CSS reset styles
Author: Nail' Gafarov
Latest version: 1.1.1

# CSS Reset

## Installation
```
npm install @stein197/css-reset
```

## Usage
In JavaScript/TypeScript:
```js
import "@stein197/css-reset/index.css";
```

In SASS:
```scss
@import "@stein197/css-reset/index";
```
npm package: @stein197/enum
Description: Complex enum implementation for JavaScript & TypeScript
Author: Nail Gafarov
Latest version: 2.1.0

# Complex enum implementation for JavaScript & TypeScript

## Installation
```
npm install @stein197/enum
```

## Motivation
TypeScript provides a very simple and primitive implementation of enumerations. All you can do with native implementation is to declare numeric or string enum values. But sometimes there is a need of more complex enumerations - that have properties or even methods. This package provides such an implementation that exists in Java and PHP.

## Usage
The package provides only one simple class `Enum` that all complex enums must extend from. Assume that there is an enum `Status` which represents HTTP statuses. Status can have status code and a message. In TypeScript it could be reached by creating two distinct enums. Instead, use complex enumerations like this:
```ts
import Enum from "@stein197/enum";

class Status extends Enum {

	public static readonly Ok = new Status(200, "Ok");
	public static readonly NotFound = new Status(404, "Not found");
	public static readonly InternalServerError = new Status(500, "Internal server error");

	public constructor(public readonly code: number, public readonly message: string) {}

	// Since it's a regular class, methods can be used as well
	public getMessage(): string {
		return this.message;
	}
}

// Unique properties
Status.NotFound.name; // "NOT_FOUND"

// Custom properties and methods
Status.Ok.message; // "Ok"
Status.Ok.getMessage(); // "Ok"

// Retrieving arbitrary data
Status.values(); // [Status.Ok, Status.NotFound, Status.InternalServerError]
Status.from("NotFound"); // By name: Status.NotFound
Status.from("Nonexistent"); // null
```

## NPM scripts
 - `clean` Cleans compiled files
 - `build`, `build:dev` Builds the project
 - `test` Runs all unit tests
npm package: @stein197/gh-sync
Description: Script that syncs all GitHub user repositories and gists
Author: Nail' Gafarov
Latest version: 0.3.0

# Script that syncs all GitHub user repositories and gists
Syncs all GitHub repositories and gists that user have to the current directory.

## Usage
Via npm:
```
npm i -g @stein197/gh-sync
gh-sync {repo | gist} --user <user> --auth <auth> [--fake]
```
Or directly from the repository:
```
node bin.js {repo | gist} --user <user> --auth <auth> [--fake]
```

Where:
- `{repo | gist}` what kind of repository to sync
- `<user>` GitHub username
- `<auth>` GitHub Access Token
- `--fake` Do not perform real actions, just see what would happen
npm package: @stein197/jsxml
Description: XML generator
Author: Nail' Gafarov
Latest version: 0.1.0

# JSXML

```
npm install @stein197/jsxml
```

```ts
import jsxml from "@stein197/jsxml";

const xml = jsxml(b => {
	b.e("html", {lang: "en"}, b => {
		b.e("head", b => {
			b.e("meta", {charset: "UTF-8"});
			b.e("meta", {"http-equiv": "X-UA-Compatible", content: "IE=edge"});
			b.e("meta", {name: "viewport", content: "width=device-width, initial-scale=1.0"});
			b.e("title", "Document");
		});
		b.e("body");
	});
});

// Or use methods corresponding to tha tag names. HTML, SVG and MathML tags are supported
const xml = jsxml(_ => {
	_.html({lang: "en"}, _ => {
		_.head();
		_.body();
	});
});

// And then stringify it...
console.log(xml.stringify({mode: "xml", output: "prettified"}));
// ...or return DOM structure
document.body.append(xml.dom());
```

## NPM scripts
- `clean` - deletes compiled files
- `build` - compiles TypeScript source code
- `test` - runs unit tests
npm package: @stein197/observer
Description: Library that provides an ability to use observer pattern
Author: Nail' Gafarov
Latest version: 2.0.0

# Observer pattern implementation for TypeScript
This tiny package implements the `observer` pattern.

## Installation
Run:
```
npm i @stein197/observer
```

## Usage
```ts
import Event from "@stein197/observer/Event";
class JoinEvent extends Event {}
class LeaveEvent extends Event {}
const dispatcher = new EventDispatcher<[JoinEvent, LeaveEvent]>();
dispatcher.addEventListener(JoinEvent, event => {}); // Adding listener on JoinEvent event
dispatcher.addEventListener(LeaveEvent, event => {}); // Adding listener on LeaveEvent event
dispatcher.dispatch(JoinEvent, new JoinEvent()); // Firing all listeners subscribed on "AfterJoin" event
dispatcher.dispatch(LeaveEvent, new LeaveEvent()); // Firing all listeners subscribed on "AfterUnjoin" event
```

Every class that emits event must implement `EventEmitter` interface:
```ts
import type {EventEmitter} from "@stein197/observer/EventEmitter";

class User implements EventEmitter<[]> {
	public addEventListener(/* ... */) {/* ... */}
	public removeEventListener(/* ... */) {/* ... */}
}
```

## NPM scripts
- `clean` cleans working directory
- `build` compiles source code
- `test` runs unit tests
npm package: @stein197/point
Description: N-dimentional point implementation
Author: Nail' Gafarov
Latest version: 1.1.0

# N-dimentional point implementation
This tiny package contains only one class `Point` that can be used to represen any-dimentional points.

## Installation
```
npm i @stein197/point
```

## Usage
Represents an N-dimentional point which can be applied in both two or three dimentions and more. Basic usage is:
```ts
let p = new Point<3>(0, 1, 2); // three-dimentional point
p.vector; // [0, 1, 2]: plain tuple
p.x; // 0
p.y; // 1
p.z; // 2
```
When working with two-dimentional points it's worth using static `Point.create()` function which excludes
redundant `z` property from the instance:
```ts
let p = Point.create<2>(1, 2);
p.x; // 1
p.y; // 2
p.z; // Error - z does not exist
```
The same applies to one-dimentional points:
```ts
let p = Point.create<1>(1);
p.x; // 1
p.y; // Error - y does not exist
```

## API
| Method | Return type | Description |
|---|---|---|
| `Point<N>.getDistance(point: Point<N>)` | `number` | Resolves the distance length between two points |
| `Point.interpolate<N>(p1: Point<N>, p2: Point<N>, t: number)` | `Point<N>` | Returns a new point at t between points p1 and p2 |

## NPM scripts
- `build` builds the project
- `test` runs unit tests
npm package: @stein197/pwd
Description: Password generator
Author: Nail' Gafarov
Latest version: 1.2.0

# Simple password generator

## Installation & Usage
Clone the repo and run it like this:
```
node bin.js [--length=<length>] [--no-numbers] [--no-symbols] [--no-lowercase] [--no-uppercase] [--no-duplicates]
```

Or like this:
```
npm i @stein197/pwd
npx pwd [--length=<length>] [--no-numbers] [--no-symbols] [--no-lowercase] [--no-uppercase] [--no-duplicates]
```

Programmatic usage:
```js
const pwd = require("@stein197/pwd");

pwd(8, {symbols: false}); // "N7v2uiaE"
```

## npm scripts
- `test` run tests
npm package: @stein197/rehook
Description: React hooks
Author: Nail' Gafarov
Latest version: 1.0.0

# Rehook
A collection of React hooks.

## Installation
```
npm install @stein197/rehook
```

## Hooks

### useAsync()
Awaits for the promise to resolve.
```tsx
function useAsync<T, U>(promise: Promise<T>): UsePromise<T, U, false>;
```

Gets a function that must return a promise and calls it on demand, which starts the process of resolving the promise.
```tsx
function useAsync<T, U>(cb: () => Promise<T>): UsePromise<T, U, true>;
```

### useBoolean()
Creates a boolean that can be toggled, switched, set.
```tsx
function useBoolean(init: boolean): UseBooleanReturn;
```

### useForce()
Forces rerender.
```tsx
function useForce(): () => void;
```

### usePrevious()
Saves the previous value.
```tsx
function usePrevious<T>(value: T): T;
```

### useImage()
Loads an image.
```tsx
function useImage(url: string): UseResourceReturn;
```

### useScript()
Loads a script.
```tsx
function useScript(url: string): UseResourceReturn;
```

### useStylesheet()
Loads a stylesheet.
```tsx
function useStylesheet(url: string): UseResourceReturn;
```

## NPM script
- `clean`. Delete all generated files
- `build`. Build the project
- `test`. Run unit tests
npm package: @stein197/restore
Description: Simple key-based store management library with React support
Author: Nail' Gafarov
Latest version: 1.0.0

# Restore
Simple key-based store management package with React support.

## Installation
```
npm install @stein197/restore
```

## Usage
```tsx
import createStore from "@stein197/restore";

const store = createStore({number: 1, string: "a"}); // Create a store with initial state
store.getValue("number");                            // 1
store.getStore();                                    // {number: 1, string: ""}
store.setValue("number", 10);                        // Set value for "number" key
store.setStore({string: "ab"});                      // Override multiple store entries
store.on("number", console.log);                     // Subscribe on "number" entry change
store.on(console.log);                               // Subscribe on every store change
function Component(): JSX.Element {
	const [value, setValue] = store.useStore();      // Using a hook that returns the whole store and a setter
	const [num, setNum] = store.useStore("number");  // Use a hook that returns a data associated with "number" field
	return (
		<div>
			<p>{JSON.stringify(value)}</p>
			<p>{num}</p>
			<button onClick={() => {
				setValue({string: "ab"});            // Override multiple store entries
				setNum(10);                          // Set value for only "number" entry
			}}>Update the store</button>
		</div>
	);
}
```

## NPM scripts
- `clean`. Delete all generated files
- `build`. Build the project
- `test`. Run unit tests
npm package: @stein197/roman
Description: Roman numbers
Author: Nail' Gafarov
Latest version: 1.0.0

# Roman numbers
Functions to work with roman numbers

## Installation
```
npm install @stein197/roman
```

## Usage
```ts
import roman from "@stein197/roman";

roman.parse("XIX"); // 19
roman.stringify(19); // "XIX"
```

## NPM scripts
- `clean`. Clean the working directory from compiled files
- `build`. Compile TypeScript source code
- `test`. Run unit tests
npm package: @stein197/rot13
Description: ROT13 cipher algorithm implementation
Author: Nail Gafarov
Latest version: 1.0.0

# JavaScript ROT13 cipher implementation
The package provindes only a single tiny `rot13()` function that converts string data according to [ROT13](https://en.wikipedia.org/wiki/ROT13) algorithm.

## Installation
```
npm install @stein197/rot13
```

## Usage
```js
const rot13 = require("@stein197/rot13");

rot13("Hello, World!") // "Uryyb, Jbeyq!"
```

## npm scripts
- `test`. Run tests
npm package: @stein197/run-script-os
Description: run-script-os is a tool that will let you use generic npm script commands that will pass through to os specific commands.
Author: Charlie Guse
Latest version: 1.1.8

# run-script-os

You will be able to use OS specific operations in npm scripts. This is a fork of original [run-script-os](https://github.com/charlesguse/run-script-os) package.

## Who would want this?
If you have experienced the pain of trying to make npm scripts usable across different operating system, this package is for you! Looking at you `rm` and `del`!

## Installation
`npm install --save-dev @stein197/run-script-os`

## Usage

Set `run-script-os` (or `run-os`) as the value of the npm script field that you want different functionality per OS. In the example below, we set `test`, but it can be any npm script. It also uses `pre` and `post` commands (explained more below).

Then create OS specific scripts. In the example below, you can see:

* `test:win32`
* `test:linux:darwin`
* `test:default`

Those can have OS specific logic.

`package.json`
```
{
  ...
  "scripts": {
    ...
    "test": "run-script-os",
    "test:win32": "echo 'del whatever you want in Windows 32/64'",
    "test:darwin:linux": "echo 'You can combine OS tags and rm all the things!'",
    "test:default": "echo 'This will run on any platform that does not have its own script'"
    ...
  },
  ...
}
```

**Windows Output:**
```
> npm test
del whatever you want in Windows 32/64
```

**macOS and Linux Output:**
```
> npm test
You can combine OS tags and rm all the things!
```

### Aliases

You can use the following aliases:

* `:windows` - Alias for win32
* `:macos` - Alias for darwin
* `:nix` - This will run on anything considered to be a *nix OS (aix, darwin, freebsd, linux, openbsd, sunos, android)
* `:default` - This will run if no platform-specific scripts are found

### Override detection settings for linux-based shells on Windows

By default, run-script-os will detect cygwin/git bash as Windows. If you would rather your platform be detected as Linux under these environments:

Set environment variable:

```
RUN_OS_WINBASH_IS_LINUX=true
```

### NPM Scripts Order
When you call a script like `npm test`, npm will first call `pretest` if it exists. It will then call `test`, which, if you are using `run-script-os`, it will then call `npm run test:YOUR OS`, which in turn will call `pretest:YOUR OS` before actually running `test:YOUR OS`. Then `posttest:YOUR OS` will run, and then after that `posttest` will finally execute.

There is an example showing `pre` and `post` commands found in the [`package.json` of this repository](https://github.com/charlesguse/run-script-os/blob/master/package.json).

OS Options: `darwin`, `freebsd`, `linux`, `sunos`, `win32`

More information can be found in [Node's `process.platform`](https://nodejs.org/api/process.html#process_process_platform) and [Node's `os.platform()`](https://nodejs.org/api/os.html#os_os_platform).
npm package: @stein197/struct
Description: Data structures
Author: Nail' Gafarov
Latest version: 1.0.0

# Data structures
The package contains a few data structures implemented in JavaScript

## Installation
```
npm install @stein197/struct
```

## Usage
To import specific data structure, just add its name to the end of "@stein197/struct/" in the import:
```ts
import Trie from "@stein197/struct/Trie";
```

## List of data structures
- `Trie`

## NPM scripts
- `build` Build the package
- `test` Run tests
npm package: @stein197/ts-util
Description: TypeScript utility types
Author: Nail Gafarov
Latest version: 1.10.0

# TypeScript utility types
This package contains most frequently used types that most projects need.

## Installation
```
npm install @stein197/ts-util
```

## Interfaces
- `Cloneable<T>`
- `Comparable<T>`
- `Equalable<T>`

## Types
- `Nullable<T>`
- `ObjectMap<T>`
- `Json`
- `JsonArray`
- `JsonObject`
- Large `MIME` module that contains all available MIME-types, described [here](https://www.iana.org/assignments/media-types/media-types.xhtml)
- Large `css` module that contains types related to CSS properties and their types.
- Large `HTMLAttributes` module that contains HTML-related typings
- `Tuple` module

> NOTE: For more detailed documentation, please, refer to the TSDoc comments in the source code.

## NPM scripts
- `make:index` generates at the root `index.ts`
- `make:mime` generates `MIME.ts` file
- `build` runs all scripts
npm package: @stein197/type
Description: TypeScript utility types
Author: Nail Gafarov
Latest version: 2.1.0

# TypeScript utility types
This package contains most frequently used types that most projects need.

## Installation
```
npm install @stein197/type
```

## Interfaces
- `Cloneable<T>`
- `Comparable<T>`
- `Equalable<T>`

## Types
- `PlainMap<T>`
- `json.Json`
- `json.JsonArray`
- `json.JsonObject`
- Large `MIME` module that contains all available MIME-types, described [here](https://www.iana.org/assignments/media-types/media-types.xhtml)
- `DeepPartial<T>`
- `DeepReadonly<T>`
- `DeepRequired<T>`
- `Tuple` module

> NOTE: For more detailed documentation, please, refer to the TSDoc comments in the source code.

## NPM scripts
- `make:index` generates at the root `index.ts`
- `make:mime` generates `MIME.ts` file
- `build` runs all scripts
npm package: @stein197/util
Description: Handy JavaScript utilities
Author: Nail' Gafarov
Latest version: 2.5.0

# Handy utilities
The package is a simple bunch of useful utilities

## Installation
```
npm install @stein197/util
```

## API
To include the module, import it like this:
```ts
import * as moduleName from "@stein197/util/moduleName";
// or
const moduleName = require("@stein197/util/moduleName");
```

**Modules**
- `array`
- `char`
- `KeyboardCode`
- `file`
- `html`
- `json`
- `mime`
- `object`
- `PendingPromise`
- `PromiseState`
- `semver`
- `string`
- `time`
- `util`

> NOTE: For more detailed documentation, please, refer to the TSDoc comments in the source code.

## npm scripts
- `build` - Run `clean`, `test` and `ts`
- `clean` - Clean the working directory from compiled files
- `test` - Run unit tests
- `ts` - Compile the project
- `ts:check` - Run TypeScript validation without compiling
npm package: @stein197/value
Description: JavaScript wrapper around values that can be observed
Latest version: 2.0.0

# JavaScript wrapper around values that can be observed
This package allows you to observe changes made on values.

## Installation
```
npm i @stein197/value
```

## Usage
The package includes only single class `Value`:
```ts
import Value from "@stein197/value";

const v = new Value(12);
v.on((oldValue, newValue) => console.log(oldValue, newValue)); // Adding an event listener. The callback takes two arguments - the old value and the new one
v.get(); // 12
v.set(12); // Does not fire an event because the new value is the same as the old one
v.set(24);
> 12 24
```

## NPM scripts
- `clean` cleans working directory from compiled files
- `ts` compiles source code
- `test` runs unit tests
- `build` all the previous scripts combined
npm package: @stein197/value-observer
Description: JavaScript wrapper around values that can be observed
Author: Nail' Gafarov
Latest version: 1.1.0

# JavaScript wrapper around values that can be observed
This package allows you to observe changes made on different values.

## Installation
```
npm i @stein197/value-observer
```

## Usage
The package comes with two classes: `Value` and `Container`. The first one is just a simple wrapper that could be used as follows:
```ts
import {Value} from "@stein197/value-observer";

const v = new Value(12);
v.addListener((oldValue, newValue) => console.log(oldValue, newValue)); // Adding an event listener. The callback takes two arguments - old value before chaging and the new one (current)
v.get(); // 12
v.set(12); // Does not fire an event because the new value is the same as the old one
v.set(24);
> 12 24
```

And the second class bundles a group of different values that can be tracked (which used `Value` class inside):
```ts
import {Container} from "@stein197/value-observer";

const c = new Container({
	age: 12,
	name: "John",
	status: "Online"
});
c.addEventListener("status", (oldValue, newValue) => console.log(oldValue, newValue)); // Tracking the change of "status" field. The usage is the same as the addListener above
c.get(); // {age: 12, name: "John", status: "Online"}
c.get("status"); // "Online"
c.set("age", 24); // Does not call the listener above
c.set("status", "Offline");
> "Online" "Offline"
```

The package also provides two interfaces similar to the classes discussed above: `ReadonlyValue` and `ReadonlyContainer` which could be used as a signature parameter in TypeScript code or implemented in other classes. "Readonly" means that the value cannot be set - only read and listen to changes:
```ts
import {ReadonlyValue, ReadonlyContainer} from "@stein197/value-observer";

function observe(value: ReadonlyValue<boolean>): void {
	value.get(); // Ok
	value.addListener(console.log); // Ok
	value.set(true); // Compile-time error
}

class AnotherContainer implements ReadonlyContainer<string> {/* ... */}

```

## NPM scripts
- `clean` cleans working directory from compiled files
- `compile` compiles source code
- `bundle` bundles compiled code into a single file
- `test` runs unit tests
npm package: @steinerjing/gutterball
Description: Utilities without bumpers
Author: steinaro
Latest version: 1.0.4

# GutterBall
__An amazong collection of one utility.__

### Utilities:
- FileActor
- \<end of list\>

## FileActor

Provides a handy function to persists data by reading from and writing to a JSON file in only a one or few lines of code.

### Import
ESM
```
import { fileActor } from '@steinerjing/gutterball'
```
CJS
```
const { fileActor } = require('@steinerjing/gutterball')
```


### Reading Data
The following is a shorthand way to read all data from the JSON file.
```
const allData = fileActor('./data/counters.json', data => data)
```
To get more specific data, create a seperate object and return it in the callback.
This example returns an array of all users with admin rights:
```
const allData = fileActor('./data/counters.json', data => {
    return data.users.filter( user => user.isAdmin )
})
```

### Changing Data
To change persistant data, make changes to the data parameter in the callback. Note that you can not change the data object itself because it is the arguemnt, but you can change any attribute about the data. The changes will persist automatically.

The following example gives all users admin rights:
```
fileActor('./data/counters.json', data => {
    data.users.forEach( user => user.isAdmin === true )
})
```

### Reading and Changing Data

Reading and changing data can both take place in the callback. As an example, the following gives all users admin rights and returns the number of total users.
```
fileActor('./data/counters.json', data => {
    data.users.forEach( user => user.isAdmin === true )
    return data.users.length
})
```

The following example increases a counter and returns the pervious counter value each time it is called. The changes are stored in the JSON file provided by the first argument. If the file doesn't exist is will be created. The data stored in the JSON file must contain an object as the root, not an array.

```
const newID = fileActor('./data/counters.json', data => data.nextMessageID++)
```
npm package: @steinkim/are-you-es5
Description: A package to help you find out which of your `node_modules` aren't ES5 so you can add them to your transpilation steps.
Author: Kim Jaesung
Latest version: 0.2.1

# are-you-es5
[![](https://img.shields.io/circleci/project/github/obahareth/are-you-es5/master.svg?style=popout)](https://circleci.com/gh/obahareth/are-you-es5)
[![](https://img.shields.io/npm/v/are-you-es5.svg?style=popout)](https://www.npmjs.com/package/are-you-es5)
![](https://img.shields.io/node/v/are-you-es5.svg?style=popout)


A package to help you find out which of your `node_modules` aren't written in ES5 so you can add them to your Webpack/Rollup/Parcel  transpilation steps. This is currently [limited to checking the entrypoint scripts only](https://github.com/obahareth/are-you-es5/issues/2), which **might** actually be enough of a check to determine if a package should be transpiled or not.

![](./.github/assets/example.png)

## Installing

You can install the package globally with

```bash
npm install -g are-you-es5
```

or if you'd rather just run it immediately you can use npx:

```bash
npx are-you-es5 check /path/to/some/repo
```

### Aliasing
If you've installed it globally and find it tiresome to type `are-you-es5` a lot, you can alias it to `es5`:

```bash
alias es5="are-you-es5"
```

# Upgrading from 1.1

If you were on version 1.1, the `-a` or `-all` option used to be for logging all messages, this has now changed to `-v` or `--verbose` and `-a` and `-all` are now used as a flag to check all node modules.

# Upgrading to 1.3

1.3 Now by default skips checking anything that has the word `babel` or `webpack`, or if a string ends with `loader`.
To restore previous behavior use the `--no-regex-filtering` option.

## Usage

```
Usage: are-you-es5 check [options] <path>

Checks if all node_modules (including monorepos) at <path> are ES5

Options:
  -a, --all             Check all node_modules instead of just direct dependencies
  -v, --verbose         Log all messages (including modules that are ES5)
  --no-regex-filtering  Stops all filtering on babel-loader exclude regex (does not hide anything)
  -r, --regex           Get babel-loader exclude regex to ignore all node_modules except non-ES5 ones, by default does not show any babel or webpack modules, use with --no-regex-filtering if you want to see everything
  -h, --help            output usage information
```

### Example

```bash
are-you-es5 check /path/to/some/repo -r
❌ @babel/plugin-1 is not ES5
❌ @babel/plugin-2 is not ES5

Babel-loader exclude regex:

/node_modules/(?![plugin-1|plugin-2])/
```

## Credits

- [acorn](https://github.com/acornjs/acorn) - All the actual ES5 checking happens through acorn, this package wouldn't exist without it.
- [es-check](https://github.com/dollarshaveclub/es-check) - This whole package wouldn't have been possible if I hadn't come across es-check and learned from it.
npm package: @steinringer/angular-ts-decorators
Description: Fork of [https://github.com/vsternbach/angular-ts-decorators](https://github.com/vsternbach/angular-ts-decorators)
Latest version: 4.0.3

Fork of [https://github.com/vsternbach/angular-ts-decorators](https://github.com/vsternbach/angular-ts-decorators)

- added simple support for controllers @Controller (not Angular2 valid)
- npm scripts ported to windows (for in loops)
- id in module is required
- added registrations to ST module system
- added ensure of $inject static property
- directive class represents directive body instead of controller in order to be able to inject services into compile and link functions

# New version release
- npm version patch -m "chore(version): increase to 4.0.3"
- npm login (steinringer credentials - confluence)
- npm run build
- npm publish dist --access public
npm package: @steinringer/focal-point
Description: [![npm version](https://img.shields.io/npm/v/@steinringer/focal-point)](https://www.npmjs.com/package/@steinringer/focal-point)
Author: Peter Zamiska
Latest version: 1.0.3

# focal-point

[![npm version](https://img.shields.io/npm/v/@steinringer/focal-point)](https://www.npmjs.com/package/@steinringer/focal-point)

# Installation
```npm
npm i @steinringer/focal-point
```


# Usage
FocalPoints are Coordinates range between -1 and 1 for both x and y axes.

To apply these coordinates you have to use FocalPointFocus class which will make some calculations on image to fit into parent container's aspect ratios and dimensions.

```html
<div style="width: 800px; height: 300px">
    <img id="focused-image" src="assets/fat-thor.jpg" alt="">
</div>
```

```ts
this.imageElement = 
    document.getElementById("focused-image") as HTMLImageElement;

this.focusedImage = new FocalPointFocus(this.imageElement, { x: 0, y: 0 });
```
## Keep in mind
Call FocalPointFocus class in case your html template is ready to view.
>f.e. In case you are using Angular, move the logic into ngAfterViewInit() lifecycle hook.
npm package: @steinringer/nuget-pckg
Description: Node.js module that scans solution folders for .nuspec files and packs packages.
Author: Jozef Lacny
Latest version: 2.2.1

﻿# nuget-pckg [![NPM version](https://badge.fury.io/js/nuget-pckg.png)](http://badge.fury.io/js/nuget-pckg)
Node.js module to pack nuGet packages from solution folder. Included a `gulpfile.js` to illustrate the functionality. Module is based on [node-nuget-runner](https://github.com/mikeobrien/node-nuget-runner) and uses Nuget.exe 3.3.0.

It provides a stream based API for gathering multiple `*.nuspec` files, packing them into `*.nupkg` packages and pushes and publishes it into remote source (with support of http sources) with Nuget Push command. Look [here](https://docs.microsoft.com/en-gb/nuget/reference/cli-reference/cli-ref-push) for more details.

Install this node module using npm install nuget-pckg --save-dev.

#### Usage:
```javascript
var Ng = require('nuget-pckg'),
path = require('path');

Ng.getNuspecs({
    baseDir: path.resolve('.'),
    skip: ['obj'],  //patterns to be skipped when searching for nuspec in baseDir
    log: true
})
.pipe(Ng.pack({
    outputDirectory: './nupkg-publish-folder',
    log: true
}))
.pipe(Ng.push({
    source,
    apiKey: apiKey,
    log: true
}));

```
See the [gulpfile](https://github.com/mcsdodo/nuget-pack/blob/dev/gulpfile.js) for additional examples.

##### Test
```
npm test
```

##### Old usage - up to version 1.0.6:

```javascript
var Ng = require('nuget-pckg');

var directory = 'solution-folder';
var ng = new Ng({
    baseDir: directory,
    outputPath: 'C:\\deploy',
    skip: ['some-regex']
});
ng.pack();
```

##### Changelog:
2.2.0 - introduced 'push' function which allows to pack and publish nuget package into remote source (support http sources)

2.0.0 - not backward compatible. Introduced stream API, added support for Nuget Add command, Nuget.exe updated. Method signatures changed (see description above). require('nuget-pckg') retuns an instance already.

1.0.6 - updated dependencies find (0.1.7 -> 0.2.4) and nuget-runner (0.1.5 -> 0.1.8)

1.0.5 - updated nuget.exe to version 3.3
npm package: @steinv/filippine
Description: Filippine - acrostic word puzzle with Angular
Author: stein vanmassenhove
Latest version: 0.0.12

# [![GitHub license](https://img.shields.io/badge/license-mit-green.svg)](https://github.com/steinv/filippine/blob/main/projects/filippine/LICENSE) Filippine

Filippine puzzle with Angular
![Example](https://github.com/steinv/filippine/blob/main/projects/filippine/assets/example.png)

## Usage

1. Install from npm
`npm install @steinv/filippine`

2. Import the module in your **app.module.ts**
```ts
import { FilippineModule } from '@steinv/filippine';

@NgModule({
  declarations: [
    ...
  ],
  imports: [
    FilippineModule,
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }
```

3. Add the filippine directive in your **component template**
```html
    <filippine 
      [configuration]="configuration" 
      (answer)="questionAnswered($event)" 
      (completed)="puzzleCompleted($event)">
    </filippine>
```

4. Add a configuration and handle output for your filippine puzzle in your **component**
```ts
  public configuration: Configuration = {
    questions: [
      {question: 'q1?', answer: 'abcdefghijklm', answerLength: 13, answerPosition: 10},
      {question: 'q2?', answer: 'abcd', answerLength: 4, answerPosition: 1},
      {question: 'q3?', answer: 'abcde', answerLength: 5, answerPosition: 2},
      {question: 'q4?', answer: 'abcdefgh', answerLength: 8, answerPosition: 2},
    ]
  }

  public questionAnswered(reply: Answer) {
    /**
     * do something with the reply: Answer 
     * reply.question
     * reply.answer
     */
  }

  public puzzleCompleted(result: boolean) {
    /**
     * do something with the result: boolean 
     */
     if (result) {
      console.log('well done!');
     } else {
      console.log('Uh-Oh looks like you made a mistake');
     }
  }
```

## Style

You can override the used css selectors to define your own custom styling
```css
/* grid-tiles used for spacing */
.spacer {
  background-color: transparent; 
  border: none;
  box-shadow: none;
}
/* grid-tiles used for input */
.input {
    background-color: white;
    border: 1px solid black;
}
/* highlighted input grid-tiles */
.highlight {
    background-color: yellow;
}
```