open-index/open-npm huggingface dataset:
npm package: @mfgames-writing/clean
Description: A plugin for mfgames-writing-format that creates a clean, functional output.
Author: Dylan R. E. Moonfire
Latest version: 3.0.5
Deprecated: this package has been renamed to @mfgames-writing/clean-theme

# Clean Theme for Moonfire Games Writing Formatter

This is a clean, minimal theme for the Moonfire Games Writing Formatter.
npm package: @mfgames-writing/clean-theme
Description: A plugin for mfgames-writing-format that creates a clean, functional output.
Author: Dylan R. E. Moonfire
Latest version: 4.3.3

# Clean Theme for Moonfire Games Writing Formatter

This is a clean, minimal theme for the Moonfire Games Writing Formatter.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/contracts
Description: Common contracts and interfaces used throughout the mfgames-writing-js libraries.
Author: Dylan R. E. Moonfire
Latest version: 5.1.3

# Contracts for MfGames Writing (JavaScript)

This is the contracts package which contains TypeScript definitions (`.d.ts`) and common data structures.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/epub2
Description: A plugin for mfgames-writing-format that create EPUB files.
Author: Dylan R. E. Moonfire
Latest version: 1.5.0

# EPUB Formatter Moonfire Games Writing

This plugin is used to create EPUB documents for Moonfire Games Writing Formatter.

## Including Assets

To include an asset into the EPUB, such as a font, use the following:

```yaml
editions:
  epub:
    format: "@mfgames-writing/epub2"
    assets:
      - path: relative/path/to/font.ttf
        archivePath: assets/font.ttf
        mime: font/ttf

```

In the above example, the path to reference inside the EPUB is "assets/font.ttf". `path` can be used to pull in a font from `node_modules/` if desired.
npm package: @mfgames-writing/epub2-format
Description: A plugin for mfgames-writing-format that create EPUB files.
Author: Dylan R. E. Moonfire
Latest version: 2.3.3

# EPUB Formatter Moonfire Games Writing

This plugin is used to create EPUB documents for Moonfire Games Writing Formatter.

## Including Assets

To include an asset into the EPUB, such as a font, use the following:

```yaml
editions:
    epub:
        format: "@mfgames-writing/epub2"
        assets:
            - path: relative/path/to/font.ttf
              archivePath: assets/font.ttf
              mime: font/ttf
```

In the above example, the path to reference inside the EPUB is "assets/font.ttf". `path` can be used to pull in a font from `node_modules/` if desired.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/format
Description: A command-line framework for formatting books into a variety of formats and themes.
Author: Dylan R. E. Moonfire
Latest version: 4.2.7

# Moonfire Games Writing Formatter

`mfgames-writing-format` is a command-line framework for formatting Markdown-based books into a variety of formats using a JSON or YAML configuration file combined with plugins for themes and transformers. This is designed to have relatively little impact on the directory structure for the project and can run via `npm` or `make` easily.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/greekil
Description: A theme for mfgames-writing-js using Gentium.
Author: Dylan R. E. Moonfire
Latest version: 1.0.0
Deprecated: this package has been renamed to @mfgames-writing/greekil-theme

# Greekil Theme for MfGames Writing

Greekil is a writing theme for MfGames Writing that uses Gentium for the main font.
npm package: @mfgames-writing/greekil-theme
Description: A theme for mfgames-writing-js using Gentium.
Author: Dylan R. E. Moonfire
Latest version: 2.3.3

# Greekil Theme for MfGames Writing

Greekil is a writing theme for MfGames Writing that uses Gentium for the main font.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/guillemet
Description: A pipeline process to convert `<<` and `>>` into guillemets.
Author: Dylan R. E. Moonfire
Latest version: 1.0.0
Deprecated: this package has been renamed to @mfgames-writing/guillemet-pipeline

# Guilllemet plugin support for MfGames Writing (Javascript).

This is a pipeline module which converts `<<` and `>>` into guillemets (`«` and `»` respectively). This is used for those who use those forms of quotation in their writing.

This plugin is used in the `pipeline` elements inside a `publication.yaml` file.

```yaml
contents:
  - element: chapter
    number: 1
    directory: chapters
    source: /^chapter-\d+.markdown$/
    start: true
    page: 1
    pipeline: &pipelines
      - module: fedran-hyphen
```
npm package: @mfgames-writing/guillemet-pipeline
Description: A pipeline process to convert `<<` and `>>` into guillemet-pipelines.
Author: Dylan R. E. Moonfire
Latest version: 2.2.2

# Guilllemet plugin support for MfGames Writing (Javascript).

This is a pipeline module which converts `<<` and `>>` into guillemets (`«` and `»` respectively). This is used for those who use those forms of quotation in their writing.

This plugin is used in the `pipeline` elements inside a `publication.yaml` file.

```yaml
contents:
    - element: chapter
      number: 1
      directory: chapters
      source: /^chapter-\d+.markdown$/
      start: true
      page: 1
      pipeline: &pipelines
          - module: fedran-hyphen
```

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/html-format
Description: A plugin for mfgames-writing-format to create HTML files.
Author: Dylan R. E. Moonfire
Latest version: 1.2.2

# EPUB Formatter Moonfire Games Writing

This plugin is used to create EPUB documents for Moonfire Games Writing Formatter.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/hyphen
Description: A pipeline process to hyphenate source documents for MfGames Writing (Javascript).
Author: Dylan R. E. Moonfire
Latest version: 0.4.10
Deprecated: Renamed for consistency, use @mfgames-writing/hyphen-pipeline instead

# Hyphenation plugin support for MfGames Writing (Javascript).

This is a pipeline module which applies hyphenation to source files in a consistent manner. It updates the text to use numerical version of `&shy;` to indicate where a word could be broken if appropriate.
npm package: @mfgames-writing/hyphen-pipeline
Description: A pipeline process to hyphenate source documents for MfGames Writing (Javascript).
Author: Dylan R. E. Moonfire
Latest version: 2.1.2

# Hyphenation plugin support for MfGames Writing (Javascript).

This is a pipeline module which applies hyphenation to source files in a consistent manner. It updates the text to use numerical version of `&shy;` to indicate where a word could be broken if appropriate.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/liquid-theme
Description: A support library for creating Liquid-based theme for MfGames Writing (Javascript).
Author: Dylan R. E. Moonfire
Latest version: 2.3.5

# Liquid theme support for MfGames Writing (Javascript).

This is a support library for implementing a Liquid-based theme inspired by Jekyll's theme processing. This also uses SASS for CSS generation.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/ncx
Description: Library for reading, manipulating, and writing NCX entries which are commonly used with EPUB files.
Author: Dylan R. E. Moonfire
Latest version: 1.1.3

# NCX

`mfgames-ncx` is a library for reading, manipulating, and writing out NCX (Navigation Center eXtended) files used for EPUB and Open Packaging Format files.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/opf
Description: Library for reading, manipulating, and writing OPF entries used for EPUB and MOBI files.
Author: Dylan R. E. Moonfire
Latest version: 1.1.4

# OPF

`mfgames-opf` is a library for reading, manipulating, and writing out OPF (Open Packaging Format) files used with EPUB files.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgames-writing/weasyprint
Description: A formatter plugin for mfgames-writing-format that creates PDF files.
Author: Dylan R. E. Moonfire
Latest version: 4.4.0

# Base PDF Formatter Moonfire Games Writing

This plugin is the base for plugins that create PDF files. This is intended to be extended by other plugins to handle application-specific functionality such as `WeasyPrint` or `wkhtmltopdf`.
npm package: @mfgames-writing/weasyprint-format
Description: A formatter plugin for mfgames-writing-format that creates PDF files.
Author: Dylan R. E. Moonfire
Latest version: 5.2.3

# Base PDF Formatter Moonfire Games Writing

This plugin is the base for plugins that create PDF files. This is intended to be extended by other plugins to handle application-specific functionality such as `WeasyPrint` or `wkhtmltopdf`.

[^project]: Project: 01947839-fc77-7f19-8d03-e576f477e15c
npm package: @mfgx/shared-lib-http-client-graphql
Description: An GraphQL client that allows deferred execution of GraphQL requests.
Author: MFGx, LLC
Latest version: 3.35.0

# MFGx GraphQL Client

This package contains an GraphQL client implementation that allows for deferred execution of GraphQL requests.

## graphqlRequest

The function takes in a GraphQL Request and returns a Reader of Async where the environment is an HttpEnvironment (see http-client). It also applies a transformation to the HttpResponse to handle GraphQL responses.

`GraphQLRequest :: { query: String, variables?: Object }`
`graphqlRequest :: GraphQLRequest -> ReaderT HttpEnvironment (Async Error Object)`
npm package: @mfields/lib
Description: A collection of JavaScript functions.
Author: Michael Fields
Latest version: 1.1.1

# @mfields/lib

A node package that contains a collection of functions for use in development of JavaScript projects. Please see [API Documentation](https://mfields.github.io/jsLib/) for more information.

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
[![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
npm package: @mfilin/eslint-config
Description: Extendable configuration for eslint
Author: Mikhail Filin
Latest version: 2.0.0

![npm publish status](https://github.com/mikhail-filin/eslint-config/actions/workflows/npm-publish.yml/badge.svg)

# @mfilin/eslint-config

Extendable configuration for eslint

## Installation

```bash
npm i --save-dev @mfilin/eslint-config
```

## Configuration

### ESLint Flat Config (Recommended)

Create an `eslint.config.js` file in your project root:

```js
import mfilinConfig from '@mfilin/eslint-config';

export default [
  ...mfilinConfig,
  // Your custom configuration
  {
    rules: {
      // Your custom rules
    }
  }
];
```

### Legacy Configuration (Deprecated)

In package.json:

```json
"eslintConfig": {
  "extends": "@mfilin/eslint-config"
}
```

Or `eslint-config` part can be omitted: 
```json
"eslintConfig": {
  "extends": "@mfilin"
}
```

> **Note:** The legacy configuration is deprecated and will be removed in a future version. Please migrate to the flat config format.
npm package: @mfilin/prettier-config
Description: Shared prettier config
Author: Mikhail Filin
Latest version: 1.1.0

# @mfilin/prettier-config

Extendable prettier configuration from person who's lazy enough to pack single config as a npm package.
Comes with both prettier config and `.prettierignore`.

## Installation

```bash
npm i --save-dev @mfilin/prettier-config
```

## Configuration

There are multiple options. Note that you need only one of them, refer to [official
docs](https://prettier.io/docs/en/configuration)

In package.json:

```json
"prettier": "@mfilin/prettier-config"
```

In `.prettierrc`:

```json
"@mfilin/prettier-config"
```

## Extending .prettierignore

I'm not aware of a way to extend `.prettierignore` in a fancy way, but prettier can be run with `ignore-path` flag in
the CLI.

```bash
npx prettier . --write --ignore-path node_modules/@mfilin/prettier-config/.prettierignore
```
npm package: @mfilin/stylelint-config
Description: Extendable stylelint configuration
Author: Mikhail Filin
Latest version: 1.1.0

![npm publish status](https://github.com/mikhail-filin/stylelint-config/actions/workflows/npm-publish.yml/badge.svg)

# @mfilin/stylelint-config

Extendable stylelint configuration.

## Installation

```bash
npm i --save-dev @mfilin/stylelint-config
```

## Configuration

In package.json:

```json
"stylelint": {
  "extends": "@mfilin/stylelint-config"
}
```
npm package: @mfinelli/paginate
Description: calculate pagination for the frontend
Author: Mario Finelli
Latest version: 1.0.1

# ts-paginate

This is a typescript implementation of the most basic part of the ruby
[pagy](https://github.com/ddnexus/pagy) gem.

## usage

Install from npm using your preferred package manager, e.g., `npm`:

```shell
npm install --save @mfinelli/paginate
```

Then you can use it like so to calculate how to display a pagination component:

```typescript
import { paginate } from "@mfinelli/paginate";

// example total items and current page:
const items = 100;
const page = 2;
const perPage = 15;

const pages = Math.ceil(items / perPage);
const view = paginate(pages, page);
```

## development

This library intends to produce the same output as the `pagy` gem, so the
test suite is built by passing inputs to pagy and recording the output. You
can regenerate the test suite like so:

```shell
bundle config set --local path vendor/bundle
bundle install
bundle exec ./gentests.rb > index.test.ts
```

## license

```
The MIT License (MIT)

Copyright (c) 2024 Mario Finelli

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```
npm package: @mfissehaye/contentarize
Description: Headless CMS editing tools for React applications
Author: mfissehaye
Latest version: 0.1.9

# @mfissehaye/contentarize

Headless CMS editing tools for React applications. A powerful, flexible component library for building content management interfaces.

## Features

- 🎨 Rich text editor built on Tiptap
- 📝 Form components for CMS integration
- 🖼️ Image picker with Unsplash integration
- 🔗 URL picker component
- ♻️ Repeater component for dynamic content
- 🎯 TypeScript support
- 🎨 Tailwind CSS styling

## Installation

```bash
npm install @mfissehaye/contentarize
```

## Usage

### Basic Setup

```tsx
import { Contentarize } from '@mfissehaye/contentarize';
// Import the CSS file - REQUIRED for styles to work
import '@mfissehaye/contentarize/styles.css';

function App() {
  return (
    <Contentarize
      // your props here
    />
  );
}
```

### Tailwind CSS Integration

This package uses Tailwind CSS v4. If your project also uses Tailwind, see [TAILWIND_INTEGRATION.md](./TAILWIND_INTEGRATION.md) for detailed integration instructions.

**Quick Start**: Simply import the CSS file:
```tsx
import '@mfissehaye/contentarize/styles.css';
```

If styles aren't loading, check the [Tailwind Integration Guide](./TAILWIND_INTEGRATION.md) for troubleshooting.

## Documentation

For detailed documentation, please visit the [GitHub repository](https://github.com/mfissehaye/contentarize).

## License

MIT
npm package: @mfjs/babel-preset-env
Description: babel autoprefixer with mfjs enabled
Author: Vitaliy Akimov
Latest version: 1.1.1

# babel-preset-env-mfjs

> Babel preset augmenting [babel-preset-env](https://github.com/babel/babel-preset-env) to enable mfjs translations.

## Install

```sh
$ npm install --save-dev babel-preset-env @mfjs/babel-preset-env
```

## Usage

### Via `.babelrc` 

**.babelrc**

```json
{
  "presets": ["@mfjs/env"]
}
```

It supports the same arguments as [babel-preset-env](https://github.com/babel/babel-preset-env),
e.g.

```json
{
  "presets": [
    ["env", {
      "targets": {
        "chrome": 52
      }
    }]
  ]
}
```

To specify mfjs options use "mfjs" field in the arguments object:

```json
{
  "presets": [
    ["env", {
      "mfjs": {
        "require": "@mfjs/generators"
      }
    }]
  ]
}
```

### Via CLI

```sh
$ babel script.js --presets @mfjs/env 
```

### Via Node API

```javascript
require("babel-core").transform("code", {
  presets: ["@mfjs/env"]
});
```

## Rationale

### Why not separate preset without `env`.
The current version of mfjs transpiler supports only full ES5
syntax with a few ES6 extensions. Making separate preset and
running it after `env` will not work, because mfjs wants to
recognize the ES6 extensions it supports to generate better code.
For example for `for-of` and ES6 imports. This preset also
automatically enables env extensions mfjs doesn't support even
if they are excluded in `env`.

After mfjs implements the whole latest JS extensions
it will be a separate preset or plugin.


## LICENSE

Copyright © 2017 Vitaliy Akimov

Distributed under the terms of The MIT License (MIT).
npm package: @mfjs/cc
Description: delimited continuations
Author: Vitaliy Akimov
Latest version: 1.2.0

# Multi-prompt delimited continuations in JavaScript.


The library is intended to be used with
[@mfjs/compiler](https://github.com/awto/mfjs-compiler). It closes up the
circle of effects encoding. It is well known many monadic effects may
be encoded using delimited continuation, details are in [Andrzej Filinski from 1994][1].
There is also backward encoding namely, given in [another paper][2]. This library
implements interface from that paper.

So from time to time some people even wonder if functional programming matters
at all. It is enough if runtime system supports delimited continuation to embed
pretty all effects embeddable with mfjs transpiler, but without any
preprocessor. Well, I’m pretty sure browsers will never implement runtime support
for delimited continuations, as there is still no even tail calls optimization.
However there is one other thing. Monadic structure provides more information for
analyzing and generating more effective code. There is some elaboration about this
in `@mfjs/compiler’ docs. 

There is a `CC.makeMonad` function, taking `bind`, `pure` functions and predicate
for checking if the value is monadic and returning. The function returns a
fully compatible monad definition implemented on top of delimited continuation monad.
This seem to be an overhead, converting to CC interface and after converting to monad
interface, but, for some monads, like Rx.Observable this is still faster for parts
of code without effects.

For example:

```javascript
var
  M = require('@mfjs/core'),
  CC = require('@mfjs/cc'),
  RxM = CC.makeMonad(
    Rx.Observable.prototype.flatMapLatest,
    Rx.Observable.return,
    Rx.Observable.isObservable
    );
  M.profile('defaultFull');

  function f1() {
    var k = Rx.Observable.from([1,2,3,4]);
    var l = Rx.Observable.from([10,20,30,40]);
    return k + l;
  }
```

## Usage

```
$ npm install --save-dev @mfjs/compiler
$ npm install --save @mfjs/core @mfjs/cc
$ mfjsc input.js --output=out
# or for browser
$ browserify -t @mfjsc/compiler/monadify input.js -o index.js
```

## References

[1]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.43.8213
     "Representing Monads, Andrzej Filinski."
[2]: http://www.cs.indiana.edu/cgi-bin/techreports/TRNNN.cgi?trnum=TR615
     "A Monadic Framework for Delimited Continuations, R. Kent Dybvig, Simon Peyton Jones, Amr Sabry."

## License

Copyright © 2016 Vitaliy Akimov

Distributed under the terms of the [The MIT License (MIT)](LICENSE).
npm package: @mfjs/core
Description: abstract runtime library for @mfjs/compiler
Author: Vitaliy Akimov
Latest version: 1.2.4

# mfjs-core

Library provides utilities for implementing monads with interfaces compatible
with [mfjs compiler](https://github.com/awto/mfjs-compiler). 

It doesn’t implement any concrete effects but it contains tools for monads
construction used by in other libraries.

Monad is encoded in the library using simple object with a set of functions
for operations. It exports a prototype with a set of default implementations
as `MonadDict`. There are also a few transformers for definitions. They add
some common boilerplate features into concrete monad definitions.

Library stores global context with current monad definition to allow usage of
several monads within same project. There are `M.setContext`, `M.liftContext`,
`M.withContext` function to manage its value. To add context management into
some definition use `M.addContext` transformer.

Because of global context storing it is critical only single instance of the
library is loaded at the moment, for example using peer dependencies.

The generated code expects some functions to be method of monadic values.
To add default implementations to prototype of monadic value use `M.addMethods`
and `M.completePrototype` functions.

Sometime same data type may be used as monadic value of several monads, or
developer simply doesn't want to pollute some probably external type with
more prototype methods. To avoid this use `M.wrap` function.

`M.withControlByToken` transformer implements JS control operators using
special value threading through monad steps and probably ignoring or changing
behavior of some of them.

For more information about mentioned functions check [API reference](doc/api.md).



## LICENSE

License

Copyright © 2016 Vitaliy Akimov

Distributed under the terms of the The MIT License (MIT).
npm package: @mfjs/logic
Description: mfjs interface for logic programming
Author: Vitaliy Akimov
Latest version: 1.1.0

# Logic programming in JavaScript

The library is based on
[Backtracking, Interleaving, and Terminating Monad Transformers](http://okmij.org/ftp/papers/LogicT.pdf)

Using it with [@mfjs/compiler](https://github.com/awto/mfjs-compiler) turns
JavaScript into a logical programming language.

For example, here is almost literal translation of classical Prolog
bi-directional list append function to JavaScript (defined in separate
[samples project](https://github.com/awto/mfjs-samples/tree/master/unify)):

```javascript
function append(a,b,r) {
  const [h, t, rt] = newRefs()
  unify(a, cons(h, t))
  unify(r, cons(h, rt))
  append(t, b, rt)
  M.answer()
  unify(a, nil())
  unify(r, b)
}
```

with usages:

```javascript
let l1 = List.from([1,2,3])
let l2 = List.from(['a','b','c'])
// free variables:
let [l3,l4,l5] = newRefs()

append(l1, l2, l3)
console.log('append:', List.toArray(l3))
// ==> append: [ 1, 2, 3, 'a', 'b', 'c' ]

append(l1, l4, l3)
console.log('suffix', List.toArray(l4))
// ==> suffix [ 'a', 'b', 'c' ]

append(l5, l2, l3)
console.log('prefix', List.toArray(l5))
// ==> prefix [ 1, 2, 3 ]
```

or non-determenistic with only result defined:

```javascript
let [x,y] = newRefs()
let z = List.from([1,2,3,4])
// only result is instantied 
append(x,y,z)
console.log('x:', List.toArray(x))
console.log('y:', List.toArray(y))
console.log('z:', List.toArray(z))
```

outputs all 5 possible answers:

```
x: [ 1, 2, 3, 4 ]
y: []
z: [ 1, 2, 3, 4 ]

x: [ 1, 2, 3 ]
y: [ 4 ]
z: [ 1, 2, 3, 4 ]

x: [ 1, 2 ]
y: [ 3, 4 ]
z: [ 1, 2, 3, 4 ]

x: [ 1 ]
y: [ 2, 3, 4 ]
z: [ 1, 2, 3, 4 ]

x: []
y: [ 1, 2, 3, 4 ]
z: [ 1, 2, 3, 4 ]
```

## API

In standard Prolog language there is only depth first search options for
possible answer lookup. The library provides means to add arbitrary search
strategies. By default it provides depth-first and breadth-first searches.

Result object returned from `L.run` is ES iterable. Its default iterator
traverses answers in depth-first order. The result object also has `bfs`
function returning iterator for breadth first order.

There are a few additional functions in logic monad definition:

 * once - takes logical computation and returns only its first answer if any
 * level - for logical computation returns object with either field `value`
   or `alts`, the first is final result of the computation and the second
   is a list of other logical computations if original one was non-deterministic

## Usage

```
$ npm install --save-dev @mfjs/compiler
$ npm install --save @mfjs/core @mfjs/logic
$ mfjsc input.js --output=out
# or for browser
$ browserify -t @mfjsc/compiler/monadify input.js -o index.js
```

## 

## License

Copyright © 2016 Vitaliy Akimov

Distributed under the terms of the [The MIT License (MIT)](LICENSE).
npm package: @mfjs/promise
Description: direct style promises
Author: Vitaliy Akimov
Latest version: 1.1.2

# @mfjs/promise

This is a tiny wrapper converting Promise ES compatible API to mfjs interface,
embedding direct  asynchronous programming into JavaScript. 

## Usage

    $ npm install --save-dev @mfjs/compiler
    $ npm install --save @mfjs/core @mfjs/promise
    $ mfjsc input-file.js -o dist

    # or for browser
    $ npm install --save-dev browserify @mfjs/compiler
    $ npm install --save @mfjs/core @mfjs/promise
    $ browserify -t @mfjs/compiler/monadify input.js -o index.js

Here is an example ported from [yield-on-promise](https://www.npmjs.com/package/yield-on-promise),
but can work in browser too.

```javascript
var M = require('@dmjs/core');
var QM = require('@dmjs/promise');
var Q = require('q');
QM.setCtor(Q.Promise);
M.profile('defaultMinimal');

QM.run(function() {
  var result = M(addLater(1, 2));
  console.log(result); // outputs 3
});

function addLater(a, b) {
  var deferred = Q.defer();
  process.nextTick(function() {
    deferred.resolve(a + b);
  });
  return deferred.promise;
}

```

## License

Copyright © 2016 Vitaliy Akimov

Distributed under the terms of the [The MIT License (MIT)](LICENSE).
npm package: @mfjs/rx
Description: interface wrapper from Rx to @mfjs/core
Author: Vitaliy Akimov
Latest version: 1.1.0

# @mfjs/rx

The library is intended to be used with
[@mfjs/compiler](https://github.com/awto/mfjs-compiler)
to turn JavaScript into reactive programming language.

## Usage

    $ npm install --save-dev @mfjs/compiler
    $ npm install --save @mfjs/core rx @mfjs/rx
    $ mfjsc input-file.js -o dist

    # or for browser
    $ npm install --save-dev browserify @mfjs/compiler
    $ npm install --save @mfjs/core rx @mfjs/rx
    $ browserify -t @mfjs/compiler/monadify input.js -o index.js

Since Observable monad is quite heavy it is better to use the library
with minimal profile where only values wrapped with M are bound.

```javascript
const M = require('@mfjs/core')
const RxM = require('@mfjs/rx')()

RxM.run(function() {
  for (let i = 1; i < 4; ++i)
    M.yield(i)
  M.empty();
})

```

Will return observable signaling 1,2,3.

## Configuration

The call to `require('@mfjs\rx')` returns function for constructing 
monad definition object. There are a few options:

 * `latest` - by default monad will use flatMap as in original RX .NET LINQ 
              mapping, but if this field is true it will instead use flatMapLatest
 * `exception` - the resulting monad will use `Observable::catch` and 
                 `Observable::handle` functions for encoding try-catch statement. 
                 Or otherwise by default it will use default token based control signaling.
 * `wrap` - this option doesn’t change semantics but it wraps Observable into a wrapper 
            so original Observable prototype isn’t changed.

## License

Copyright © 2016 Vitaliy Akimov

Distributed under the terms of the [The MIT License (MIT)](LICENSE).
npm package: @mfl/block-device-listener
Description: Listens for block device add / removes. Writes to device-scanner-daemon socket.
Author: MFL Team
Latest version: 0.1.0

# block-device-listener

A [net.Socket](https://nodejs.org/api/net.html) client that is started when it receives a udev event for {ADD|REMOVE} of block devices.

The client will write to the unix domain socket of `device-scanner-daemon` with the new event data. It acts as a middleman.

Udev event data is written over [process.env](https://nodejs.org/api/process.html) to this module.
npm package: @mfl/debounce
Description: Module to debounce changes
Author: MFL Team
Latest version: 1.0.1

# debounce

[![Build Status](https://travis-ci.org/intel-hpdd/debounce.svg?branch=master)](https://travis-ci.org/intel-hpdd/debounce)
[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/debounce.svg)](https://greenkeeper.io/)

Module to debounce changes

Debounces changes over a given interval. Can be scheduled to call
at the leading edge.

### API

debounce : Function -> Number -> Boolean -> Function
npm package: @mfl/deep-freeze
Description: Recursively freezes a JSON like object tree
Author: MFL Team
Latest version: 2.0.2

# deep-freeze

[![Build Status](https://travis-ci.org/intel-hpdd/deep-freeze.svg?branch=master)](https://travis-ci.org/intel-hpdd/deep-freeze)

Freezes an Object tree recursively. Does not detect cycles, so use this only on JSON like objects, not on a graph.

Also, this is useful for testing to assert your objects are not being mutated. There are not many situations where you
would want this code to create immutable objects in production.
npm package: @mfl/device-scanner-daemon
Description: A persistent process that consumes udev events over a unix domain socket.
Author: MFL Team
Latest version: 0.1.0

# device-scanner-daemon

A persistent process that consumes udev events over a unix domain socket.

## Overview

There are two main modes to this daemon:

1. Processing new incoming events. In this mode we will munge and store incoming events.

2. Send current devices object listing. In this mode we will send our current stored devices.

We use unix domain sockets to communicate with the outside world.

Consumers can send a Request over the socket to retrieve the current listing:

`"Info"`


## Architecture

```
         ┌───────────┐
         │   Udev    │
         └───────────┘
               │
               │
               │
       ┌───────┴────────┐
       │   Run Script   │
       └───────┬────────┘
               │
               │
               ▼
  ┌─────────────────────────┐
  │  Block-Device Listener  │
  └─────────────────────────┘
               │
               │
               │
               │
   ┌───────────┴──────────┐
   │  Unix Domain Socket  │
   └───────────┬──────────┘
               │
               │
               ▼
┌────────────────────────────┐
│   Device Scanner Daemon    │
└────────────────────────────┘
               ▲
               │
               │
               │
    ┌──────────┴──────────┐
    │ Unix Domain Socket  │
    └──────────┬──────────┘
               │
               │
               │
               ▼
     ┌──────────────────┐
     │ Consumer Process │
     └──────────────────┘
```
npm package: @mfl/flat-map-changes
Description: Highland.js flatMap transform that creates a new source when it's upstream changes.
Author: MFL Team
Latest version: 1.0.3

# flat-map-changes

[![Build Status](https://travis-ci.org/intel-hpdd/flat-map-changes.svg?branch=master)](https://travis-ci.org/intel-hpdd/flat-map-changes)
[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/flat-map-changes.svg)](https://greenkeeper.io/)

highland.js flatMap transforms that create a new source when it's upstream changes.
npm package: @mfl/flow-highland
Description: A module to hold highland flow types
Author: MFL Team
Latest version: 4.2.8

# flow-highland

[![Build Status](https://travis-ci.org/intel-hpdd/flow-highland.svg?branch=master)](https://travis-ci.org/intel-hpdd/flow-highland)
[![Greenkeeper badge](https://badges.greenkeeper.io/intel-hpdd/flow-highland.svg)](https://greenkeeper.io/)

This is a simple module to host highland flow types.
npm package: @mfl/flow-jasmine
Description: flow-type declarations for jasmine
Author: MFL Team
Latest version: 1.6.1

# flow-jasmine

This is a simple module to host jasmine declarations.

[![Build Status](https://travis-ci.org/intel-hpdd/flow-jasmine.svg?branch=master)](https://travis-ci.org/intel-hpdd/flow-jasmine)