open-index/open-npm huggingface dataset:
npm package: @me5on/albega
Description: ## Install
Author: azder
Latest version: 0.0.3

# Al Be Ga

## Install

```bash
npm install --save-dev @me5on/albega
```

## Import as CSS

You can import it in your HTML file<sup>*</sup> as:

```html

<link href="./node_modules/@me5on/albega/css/index.css" rel="stylesheet">

```

<sup>*</sub> **NB**: You may have to check whichever path resolution is necessary for your project

## Import as SCSS

The simplest way to use it in your main SCSS file:

```scss
@use '~@me5on/albega' with (
    $main--al: #61dafb,
);
```

For more control, you can import it partially:

```scss
@use '~@me5on/albega/scss/theme' with (
    $main--al: #61dafb,
);
@use '~@me5on/albega/scss/root';
@use '~@me5on/albega/scss/mod';

```
npm package: @me5on/crayon
Description: crayon color console
Author: azder
Latest version: 0.2.0

# Crayon

```js
import crayon from '@me5on/crayon';


console.log(crayon('{: bg.red + fg.yellow :: red bg and yellow fg :}'));
```

![](https://raw.githubusercontent.com/me5on/crayon/trunk/doc/red-bg-yellow-fg.png)

```js
const {ansi: A, create} = crayon;

const custom = create({
  syntax: {
    and: ',', esc: '', dot: '',
    bgn: '\\{', mid: ':', end: '\\}',
  },
  box:    {
    dim:  A.cc.dim,
    done: A.bg.green + A.fg.white + A.cc.bright,
    warn: A.bg.yellow + A.fg.black,
    info: A.bg.blue + A.fg.black,
  },
});

console.log(custom('{dim: a dim text }'));
console.log(custom('{dim,info:MARK}'));
console.log(custom('{warn:WARN}'));
console.log(custom('{done:DONE}'));
```

![](https://raw.githubusercontent.com/me5on/crayon/trunk/doc/custom-crayons.png)

Can also use it as a tag for template strings

```js
console.log(custom`{dim,info:INFO} if crayon is {bold:NOT} in the box, it is ignored`);
console.log(custom`{warn:WARN} something went {bad:bad}` + ' no {bad:crayon found}');
console.log(custom`this example is {done:DONE}`);
```

![](https://raw.githubusercontent.com/me5on/crayon/trunk/doc/tagged-template-strings.png)

```js
const {ansi: {fg: FG, bg: BG, cc: CC}, bgf: {black}, idx: IDX, rgb: RGB} = crayon;


const c = crayon.create({
  box: {
    TXT: BG.black + IDX.fg(250) + CC.bright,
    VER: BG.black + RGB.fg(0x9f, 0x90, 0xff),
    ERR: BG.black + FG.red,
    REG: BG.black,
  },
});


const version = '1.2.3';
console.log(c`{:TXT::version: :}{:VER::${version}:}`);
console.log(c`{:TXT::version: :}{:ERR::unknown:}`);

// embedded directives don't work, so they can have similar colors
console.log(c`{:TXT::first color:} in between {:VER::second color:}`);
console.log(c`{:TXT::first background:}{:REG:: now with regular background :}{:VER::second background:}`);

// there is also no need of always using tagged template strings
console.log(black('also with the same background'));
```

![](https://raw.githubusercontent.com/me5on/crayon/trunk/doc/multiple-crayons.png)
npm package: @me5on/create
Description: Helper for creating initial files
Author: azder
Latest version: 0.0.43

![](icon.png)

# Create

## Run

```bash
npm init @me5on
```

## Cleanup before run

In case you have an earlier version stored in the NPX cache. To remove all that cache on *nix (
delete `%LocalAppData%/npm-cache/_npx` on win):

```bash
rm -rf ~/.npm/_npx
```

You can find where the NPM cache is with:

```bash
npm config get cache
```
npm package: @me5on/fn
Description: FN
Author: azder
Latest version: 0.2.0

![](doc/icon.png)

# FN

fun fun fun

A small utility library for dealing with functions

## Examples

### K

```javascript
const konst = K('this is the value', 'following args are ignored');

console.log(
  konst.name,                  // K(this is the value)
  konst.toString(),            // () => $
  konst(),                     // this is the value
  konst('different value'),    // this is the value
);
```

### ident

```javascript
const a = [0, 1, 2, 3, 4];

console.log(
  a.map(ident),                     // [ 0, 1, 2, 3, 4 ]
  a.filter(ident),                  // [ 1, 2, 3, 4 ]
);


const b = [Symbol(1), Symbol(2)];
const c = b.map(ident);

console.log(
  b.map((_, i) => b[i] === c[i]),  // [ true, true ]
);
```

### pipe and compose

```javascript
const plus10 = $ => $ + 10;
const times2 = $ => $ * 2;


const plusBeforeTimes = pipe(plus10, times2);       // ($ + 10) * 2
const plusAfterTimes = compose(plus10, times2);     // ($ * 2) + 10

console.log(
  plusBeforeTimes.name,                             // pipe(plus10,times2)
  plusAfterTimes.name,                              // compose(plus10,times2)
);

console.log(
  plusBeforeTimes(1),                               // 22
  plusAfterTimes(1),                                // 12
);
```

### tie

```javascript
const tie = FN.tie;


const a = (one, two, three) => one + two + three;
const b = function c(...$$) {
  console.log('args provided:', ...$$);
  return $$;
};

class D {
}

const f = tie(a, 1);
const g = tie(b, 'first', Symbol('second'));
const h = tie(f, 2);

const C = tie(D, 1, 2, 3);

console.log(
  f.name,     // a(1)
  g.name,     // c(first,Symbol(second))
  h.name,     // a(1)(2)
  C.name,     // D(1,2,3)
);

console.log(
  f(3),        // NaN
  h(3),        // 6
  new C(),     // D {}
);

g();            // args provided: first Symbol(second)
```
npm package: @me5on/is
Description: IS
Author: azder
Latest version: 0.2.0

![](doc/icon.png)

# IS

it?

A small utility library for checking values

## Examples

```javascript
console.log(
  IS.fun($ => $),                 // true
  IS.fun(),                       // false

  IS.nan(NaN),                    // true

  IS.int(1),                      // true
  IS.integer(1),                  // true
  IS.num.int(1),                  // true

  IS.array([]),                   // true
  IS.ar([]),                      // true
  IS.ar.empty([]),                // true
  IS.array.empty(),               // false

  IS.empty(''),                   // true
  IS.empty([]),                   // true
  IS.empty({}),                   // true
  IS.empty(null),                 // true

  IS.primitive('yes'),            // true
  IS.primitive(new String('no')), // false
);
```
npm package: @me5on/martis
Description: Markov algorithm TL;DR:
Author: azder
Latest version: 0.2.0

# MARTIS

Markov algorithm TL;DR:

- the rules are a sequence of pairs of strings;
- usually presented in the form of pattern → replacement;
- each rule may be either ordinary or terminating.

Martis TL;DR:

- same principles as above,
- a bit more utility
- all in JS.

## Examples

### Binary to unary

```javascript
const bin2uni = martis(
  {
    step: ({str}) => console.log(str),
  },
  [
    {
      pat: /\|0/,
      rep: '0||',
    },
    {
      pat: '1',
      rep: '0|',
    },
    {
      pat: '0',
      rep: '',
    },
  ],
);


bin2uni('111');
```

produces

```
0|11
0|0|1
00|||1
00|||0|
00||0|||
00|0|||||
000|||||||
00|||||||
0|||||||
|||||||
```

### Emojis

```javascript
const {r} = martis;

const replace = martis({
  step:  ({idx, str}) => console.log(idx, '->', str),
  rules: [
    r(/:\)/, '😀'),
    r(':D', '😆'),
    r('x', '😆'),
    r('😀😆', '🤣'),
    r('😀🤣', '🙃'),
  ],
});

console.log(replace(':):)x'));
```

produces

```
 1n -> 😀:)x
 2n -> 😀😀x
 3n -> 😀😀😆
 4n -> 😀🤣
 5n -> 🙃
 🙃
```

### Lower case

```javascript
const lower = martis(
  [{
    end: true,
    pat: '.*',
    rep: ({old}) => old.toLowerCase(),
  }],
);

console.log(lower('AxByCzD'));
```

produces

```
axbyczd
```

### Capitalize

```javascript
const {terminating, rule} = martis;

const capitalize = martis([

  terminating(rule(
    '(.)(.*)',
    ({tst}) => tst[1].toUpperCase() + tst[2].toLowerCase()),
  ),

]);

console.log(capitalize('AxByCzD'));         //> Axbyczd
console.log(capitalize('ABCD'));            //> Abcd
console.log(capitalize('xyz'));             //> Xyz
console.log(capitalize('?'));               //> ?
console.log(capitalize(''));                //>
console.log(capitalize());                  //>
```
npm package: @me5on/ob
Description: OB
Author: azder
Latest version: 0.2.0

![](doc/icon.png)

# OB

Accessors: getters, setters, deleters

A small utility library for dealing with objects

## Examples

```javascript
const object = {
  a:   1,
  b:   2,
  c:   3,
  d:   null,
  key: 'val',
  obj: {a: 11, b: 22, c: {}, d: null},
  arr: [1, 2, 3, {a: 111, b: 222}],
};

console.log(
  OB.get.ko('key', object),           // val
  OB.get.ok(object, 'key'),           // val

  OB.nav('arr.3.b', object),          // 222
  OB.nav(['arr', 3, 'b'], object),    // 222

  OB.nav('obj.d.e', object),          // null
  OB.nav('obj.d.1.2.3', object),      // null
  OB.nav('obj.c.1.2.3', object),      // undefined
);


const o = {};

console.log(
  OB.set.kvo$('k1', 'v1', o),     // { k1: 'v1' }
  OB.set.kvo('k22', 'v2', o),     // { k1: 'v1', k22: 'v2' }
  o,                              // { k1: 'v1' }
  OB.set.okv(o, 'k1', 'val'),     // { k1: 'val' }
  o,                              // { k1: 'v1' }
);

console.log(OB.del.ok(o, 'k1'));    // {}
console.log(o);                     // { k1: 'v1' }
console.log(OB.del.ko$('k1', o));   // {}
console.log(o);                     // {}
```
npm package: @me5on/to
Description: TO
Author: azder
Latest version: 0.2.0

# TO

something

A small utility library for converting values from something `TO` something else

## Examples

```javascript
const emptyString = TO.str(null);
const oneAsString = TO.string(1);

const number = TO.number('1234');
const infinity = TO.num(Infinity);
const nan = TO.num('invalid');

const numBool = TO.bool(number);
const infBool = TO.bul(infinity);
const nanBool = TO.boolean(nan);

console.log(
  emptyString,          // ""
  oneAsString,          // "1"
  typeof oneAsString,   // "string"

  number,               // 1234
  typeof number,        // "number"
  nan,                  // NaN
  infinity,             // Infinity

  numBool,              // true
  infBool,              // true
  nanBool,              // false
);
```
npm package: @me7/totp
Description: Time-Based One-Time Password Algorithm (RFC 6238)
Author: Gampol T.
Latest version: 1.3.0

# @me7/totp

![npm badge](https://img.shields.io/npm/v/@me7/totp)
![](https://img.shields.io/bundlephobia/minzip/@me7/totp)

Time-Based One-Time Password Algorithm (RFC 6238)
npm package: @me_slack/vue3easyform
Description: Credit to @lmiller1990 for sharing how to build packages in NPM for Vue3 as Vue have still not documented the process.
Author: Andy Slack
Latest version: 0.0.1

## VueEasyForm

Credit to @lmiller1990 for sharing how to build packages in NPM for Vue3 as Vue have still not documented the process.

A `<VSwitch>` component for Vue.js 3.

## Installation

```sh
yarn add @lmiller1990/v-switch

npm install @lmiller1990/v-switch
```

## Usage

`<VSwitch>` is modeled after the `switch` statement we all know and love.

```vue
<template>
  <v-switch :case="size">
    <template #big>
      Big
    </template>

    <template #small>
      Small
    </template>

    <template #default>
      Default
    </template>
  </v-switch>
</template>

<script lang="ts">
import { defineComponent, ref } from 'vue'
import VSwitch from '@lmiller1990/v-switch'

export default defineComponent({
  components: {
    VSwitch
  },
  setup() {
    return {
      size: ref('big')
    }
  }
})
</script>
```

It also works with dynamic slots:

```vue
<template>
  <v-switch :case="number">
    <template 
      v-for="num in numbers"
      v-slot:[num]
    >
      Number: {{ num }}
    </template>

    <template #default>
      Default
    </template>
  </v-switch>
</template>

<script lang="ts">
import { defineComponent, ref } from 'vue'
import VSwitch from '@lmiller1990/v-switch'

export default defineComponent({
  components: {
    VSwitch
  },

  setup() {
    const number = ref(1)
    const numbers = [1,2,3,4,5]

    return {
      number,
      numbers
    }
  }
})
</script>
```

If you are using the browser build, or you like to register components globally, that works fine, too:

```js
// with a bundler
import { createApp } from 'vue'
const app = createApp(/* ... */)
app.component('v-switch', VSwitch)

// or using the global build
// assumes Vue is available globally - VSwitch is available globally via `VSwitch`
const app = Vue.createApp(/* ... */)
app.component('v-switch', VSwitch)
```

## Builds

There are three builds available.

- `dist/v-switch.cjs,js`: for SSR in node.js (using `require`)
- `dist/v-switch.esm-bundler.js`: for bundlers like Webpack and Rollup
  - also works as an ES module in the browser using `<script type="module">`
- `dist/v-switch.browser.js`: global build (iife)

Type definitions are also included.

Generally your build tool will be able to figure out which bundle to use, but you can be explicit if you need to.

## Other

I recorded some content for my YouTube channel relating to this component:

- Building the component: https://youtu.be/KPV6-H6-IxM 
- Building for production and publishing it on npm: https://youtu.be/KwoO2afF5cg

## License

MIT
npm package: @meadow/eslint-config
Description: Extendable ESLint configuration by Meadow
Latest version: 5.0.3

# eslint-config

[Extendable ESLint configuration](http://eslint.org/docs/developer-guide/shareable-configs) used at [Meadow](https://getmeadow.com).

## Usage

```bs
npm install --save-dev @meadow/eslint-config
```

`.eslintrc`:

```json
{
    "extends": "@meadow"
}
```