open-index/open-npm huggingface dataset:
npm package: @kingjs/linq.then-by
Description: Generates a sequence of elements from a sorted sequence where elements previously considered equal are put in ascending order according to a key.
Author: Chris King
Latest version: 1.0.6

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).then-by
Generates a sequence of elements from a sorted sequence where elements previously considered equal are put in ascending order according to a key.
## Usage
Sort `Bob Smith`, `Alice Smith`, and `Chris King` in ascending order by last name then first name like this:
```js
var orderBy = require('@kingjs/linq.order-by');
var thenBy = require('@kingjs/linq.then-by');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var people = sequence(
  { first: 'Bob', last: 'Smith' },
  { first: 'Alice', last: 'Smith' },
  { first: 'Chris', last: 'King' },
);

var lastSelector = function(x) { return x.last; }
var firstSelector = function(x) { return x.first; }

var sortedSequence = orderBy.call(people, lastSelector);
sortedSequence = thenBy.call(sortedSequence, firstSelector);

toArray.call(sortedSequence);
```
result:
```js
[
  { first: 'Chris', last: 'King' },
  { first: 'Alice', last: 'Smith' },
  { first: 'Bob', last: 'Smith' },
]
```
## API
```ts
declare function thenBy(
  this: SortedEnumerable, 
  keySelector?: (x) => any,
  lessThan?: (l, r) => boolean,
): SortedEnumerable
```
### Interfaces
- `SortedEnumerable`: See [@kingjs/linq.order-by](https://www.npmjs.com/package/@kingjs/linq.order-by).

### Parameters
- `this`: A sorted sequence of element to subsequently sort.
- `keySelector`: Select a value by which to sort. By default, returns the element.
- `lessThan`: Compare if one key is less than another. By default, uses the `<` operator.
### Return Value
A refined sorted sequence in descending order. 
## See Also
- [@kingjs/linq.order-by](https://www.npmjs.com/package/@kingjs/linq.order-by)
- [@kingjs/linq.order-by-descending](https://www.npmjs.com/package/@kingjs/linq.order-by-descending)
- [@kingjs/linq.then-by-descending](https://www.npmjs.com/package/@kingjs/linq.then-by-descending)
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/link.then-by
```
## Acknowledgments
Like [Enumerable.ThenBy](https://msdn.microsoft.com/en-us/library/bb534500(v=vs.110).aspx)
## License
MIT

![Analytics](https://analytics.kingjs.net/linq/then-by)
npm package: @kingjs/linq.then-by-descending
Description: Generates a sequence of elements from a sorted sequence where elements previously considered equal are put in descending order according to a key.
Author: Chris King
Latest version: 1.0.7

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).then-by-descending
Generates a sequence of elements from a sorted sequence where elements previously considered equal are put in descending order according to a key.
## Usage
Sort `Bob Smith`, `Alice Smith`, and `Chris King` in descending order by last name then first name like this:
```js
var orderByDescending = require('@kingjs/linq.order-by-descending');
var thenByDescending = require('@kingjs/linq.then-by-descending');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var people = sequence(
  { first: 'Bob', last: 'Smith' },
  { first: 'Alice', last: 'Smith' },
  { first: 'Chris', last: 'King' },
);

var lastSelector = function(x) { return x.last; }
var firstSelector = function(x) { return x.first; }

var sortedSequence = orderByDescending.call(people, lastSelector);
sortedSequence = thenByDescending.call(sortedSequence, firstSelector);

toArray.call(sortedSequence);
```
result:
```js
[
  { first: 'Bob', last: 'Smith' },
  { first: 'Alice', last: 'Smith' },
  { first: 'Chris', last: 'King' },
]
```
## API
```ts
declare function thenByDescending(
  this: SortedEnumerable, 
  keySelector?: (x) => any,
  lessThan?: (l, r) => boolean,
): SortedEnumerable
```
### Interfaces
- `SortedEnumerable`: See [@kingjs/linq.order-by](https://www.npmjs.com/package/@kingjs/linq.order-by).

### Parameters
- `this`: A sorted sequence of element to subsequently sort.
- `keySelector`: Select a value by which to sort. By default, returns the element.
- `lessThan`: Compare if one key is less than another. By default, uses the `<` operator.
### Return Value
A refined sorted sequence in descending order. 
## See Also
- [@kingjs/linq.order-by](https://www.npmjs.com/package/@kingjs/linq.order-by)
- [@kingjs/linq.order-by-descending](https://www.npmjs.com/package/@kingjs/linq.order-by-descending)
- [@kingjs/linq.then-by](https://www.npmjs.com/package/@kingjs/linq.then-by)
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/link.then-by-descending
```
## Acknowledgments
Like [Enumerable.ThenByDescending](https://msdn.microsoft.com/en-us/library/bb534500(v=vs.110).aspx)
## License
MIT

![Analytics](https://analytics.kingjs.net/linq/then-by-descending)
npm package: @kingjs/linq.to-array
Description: Creates an array from a `IEnumerable`.
Author: Chris King
Latest version: 1.0.8

# @[kingjs][@kingjs]/[linq][ns0].[to-array][ns1]
Creates an array from a `IEnumerable`.
## Usage
```js
require('kingjs');
var assert = require('assert');
var ToArray = require('@kingjs/linq.to-array');

var array = '123'[ToArray]();

assert(array.length = 3);
assert(array[0] === '1');
assert(array[1] === '2');
assert(array[2] === '3');

```

## API
```ts
toArray(this)
```

### Parameters
- `this`: An `IEnumerable` from which to create an array.



## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/linq.to-array
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/i-enumerable`](https://www.npmjs.com/package/@kingjs/i-enumerable)|`^1.0.6`|
|[`@kingjs/linq.aggregate`](https://www.npmjs.com/package/@kingjs/linq.aggregate)|`^1.0.20`|
|[`@kingjs/reflect.export-extension`](https://www.npmjs.com/package/@kingjs/reflect.export-extension)|`^1.0.1`|
## Source
https://repository.kingjs.net/linq/to-array
## License
MIT

![Analytics](https://analytics.kingjs.net/linq/to-array)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/linq
[ns1]: https://www.npmjs.com/package/@kingjs/linq.to-array
npm package: @kingjs/linq.to-dictionary
Description: Creates a dictionary from a sequence where the dictionary keys and values are projected from each element.
Author: Chris King
Latest version: 1.0.6

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).to-dictionary
Creates a dictionary from a sequence where the dictionary keys and values are projected from each element.
## Usage 
Create a dictionary of people's ages by their name like this:
```js
var sequence = require('@kingjs/enumerable.create');
var toDictionary = require('@kingjs/linq.to-dictionary');

toDictionary.call(
  sequence(
    { name: 'Alice', age: 18 },
    { name: 'Bob', age: 19 },
    { name: 'Chris', age: 20 },
  ), 
  function(x) { return x.name; },
  function(x) { return x.age; }
);
```
result:
```js
{
  Alice: 18,
  Bob: 19,
  Chris: 20
}
```
## API
```ts
function toDictionary(
  this: Enumerable,
  keySelector: function(x): any,
  valueSelector?: function(x): any,
): Dictionary
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).
- `Dictionary`: See [@kingjs/dictionary](https://www.npmjs.com/package/@kingjs/dictionary).
### Parameters
- `this`: Sequence to turn into a dictionary.
- `selectKey`: Select a key for each element.
- `selectValue`: Select a value for each element.
### Return Value
Returns a dictionary of one key/value pair for each element. Throws if more than one element maps to the same key. 
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/linq.to-dictionary
```
## Acknowledgments
Like: [Enumerable.Dictionary](https://msdn.microsoft.com/en-us/library/bb548657(v=vs.110).aspx)
## License
MIT

![Analytics](https://analytics.kingjs.net/linq/to-dictionary)
npm package: @kingjs/linq.to-lookup
Description: Creates a dictionary from a sequence where values are groups of elements keyed by a name common to all members of the group.
Author: Chris King
Latest version: 1.0.8

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).to-lookup
Creates a dictionary from a sequence where values are groups of elements keyed by a name common to all members of the group.
## Usage 
If the following people own the following pets 
- Alice owns Fluffy
- Alice owns Spike
- Bob owns Tiger

then create a lookup from 
- Alice to Fluffy and Spike 
- Bob to Tiger 

like this:
```js
var toLookup = require('@kingjs/linq.to-lookup');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var lookup = toLookup.call(
  sequence(
    { name: 'Alice', pet: 'Fluffy' },
    { name: 'Alice', pet: 'Spike' },
    { name: 'Bob', pet: 'Tiger' }
  ),
  function(x) { return x.name; },
  function(x) { return x.pet; }
)

for (var key in lookup)
  lookup[key] = toArray.call(lookup[key]);
  
lookup;
```
result:
```js
{
  Alice: [ 'Fluffy', 'Spike' ],
  Bob: [ 'Tiger' ]
}
```
## API
```ts
declare function(
  this: Enumerable,
  keySelector: function(x): any,
  valueSelector?: function(x): any,
): Dictionary
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).
- `Dictionary`: See [@kingjs/dictionary](https://www.npmjs.com/package/@kingjs/dictionary).
### Parameters
- `this`: Sequence to partition into named sequences.
- `keySelector`: Selects a partition key from an element.
- `valueSelector`: Transforms an element before inclusion in a partition. By default, selects the entire element.
### Return Value
A partitioning of the sequence as a dictionary mapping partition names to partitions.  
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/linq.to-lookup
```
## Acknowledgments
Like [Enumerable.ToLookup](https://msdn.microsoft.com/en-us/library/bb548544(v=vs.110).aspx).
## License

MIT

![Analytics](https://analytics.kingjs.net/linq/to-lookup)
npm package: @kingjs/linq.union
Description: Generates the set union of two sequences.
Author: Chris King
Latest version: 1.0.10

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).union
Generates the set union of two sequences.
## Usage
Create a union of the sequences
- `0`, `0`, `1`, `2`, and
- `1`, `3`, `3` 

like this:
```js
var union = require('@kingjs/linq.union');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var result = union.call(
  sequence(0, 0, 1, 2),
  sequence(1, 3, 3)
);

toArray.call(result);
```
result:
```js
[0, 1, 2, 3]
```
Create a union of the same sequences as before but wrapped in an object like this:
```js
var union = require('@kingjs/linq.union');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var result = union.call(
  sequence({ id: 0 }, { id: 0 }, { id: 1 }, { id: 2 }),
  sequence({ id: 1 }, { id: 3 }, { id: 3 }),
  function(x) { return x.id; }
);

toArray.call(result);
```
result:
```js
[{ id: 0 }, { id: 1 }, { id: 2 }, { id: 3 }]
```
## API
```ts
function union(
  this: Enumerable, 
  second: Enumerable, 
  idSelector?: (x) => any
): Enumerable;
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).
### Parameters
- `this`: The first sequence.
- `second`: The second sequence.
- `idSelector`: Return a value whose stringified representation uniquely identifies an element.
  - `x`: The element to identify.
### Result
A sequence containing unique elements of sequences `first` and `second`.
## Remarks
Elements are deemed equal if their key's stringified representations are the same. 

Elements are included in the order they are appear in the first sequence and then the second sequence.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/link.union
```
## Acknowledgments
Like [`Enumerable.Union`](https://msdn.microsoft.com/en-us/library/bb358407(v=vs.110).aspx).
## License

MIT

![Analytics](https://analytics.kingjs.net/linq/union)
npm package: @kingjs/linq.where
Description: Generates a sequence of elements composed of elements from another sequences which satisfy a specified condition.
Author: Chris King
Latest version: 1.0.8

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).where
Generates a sequence of elements composed of elements from another sequences which satisfy a specified condition.
## Usage
Filter `0`, `1`, `2`, `3` to even numbers like this: 
```js
var where = require('@kingjs/linq.where');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var numbers = sequence(0, 1, 2, 3);

var isEven = function (x) { return x % 2 == 0; }

var evenNumbers = where.call(numbers, isEven);

toArray.call(evenNumbers);
```
result:
```js
[0, 2]
```
Filter out every other element in `'a'`, `'b'`, `'c'`, `'d'` like this: 
```js
var where = require('@kingjs/linq.where');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var letters = sequence('a', 'b', 'c', 'd');

var isEvenIndex = function (x, i) { return i % 2 == 0; }

var everyOther = where.call(letters, isEvenIndex);

toArray.call(everyOther);
```
result:
```js
['a', 'c']
```

## API

```ts
declare function where(
  this: Enumerable,
  predicate: (x, i) => boolean,
): Enumerable
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: The sequence to filter.
- `predicate`: The filtering predicate.
  - `x`: The value being considered for inclusion.
  - `i`: The index of the value being considered.

### Return Value
A sequence filtered by the predicate.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.where
```

## Acknowledgments
Like [`Enumerable.Where`](https://msdn.microsoft.com/en-us/library/bb549418(v=vs.110).aspx).

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/where)
npm package: @kingjs/linq.zip
Description: Generates a sequence of elements composed of elements of two sequences which share the same index.
Author: Chris King
Latest version: 1.0.5

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).zip
Generates a sequence of elements composed of elements of two sequences which share the same index.
## Usage
Zip the numbers `0`, `1`, `2` with the letters `a`, `b` like this:
```js
var zip = require('@kingjs/linq.zip');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var result = zip.call(
  sequence(0, 1, 2),
  sequence(`a`, `b`),
  function(n, l) { 
    return { number: n, letter: l }; 
  }
)

toArray.call(result);
```
result:
```js
[
  { number: 0, letter: 'a' },
  { number: 1, letter: 'b' }
]
```
## API
```ts
declare function zip(
  this: Enumerable,
  second: Enumerable,
  resultSelector: (firstElement, secondElement) => any
): Enumerable
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).
### Parameters
- `this`: The first sequence.
- `second`: The second sequence. 
- `resultSelector`: Joins elements of the first and second sequence which share the same index.
  - `firstElement`: Element of the first sequence.
  - `secondElement`: Element of the second sequence.
### Return Value
A sequence of elements of first sequence joined with elements of the second sequence.
## Remarks
Elements without a partner are ignored.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/linq.zip
```
## Acknowledgments
Like [`Enumerable.Zip`](https://msdn.microsoft.com/en-us/library/dd267698(v=vs.110).aspx).
## License
MIT

![Analytics](https://analytics.kingjs.net/linq/zip)
npm package: @kingjs/load-symbols
Description: ```js var assert = require('assert'); var xxx = require('@kingjs/xxx'); ``` ## API ```ts declare function xxx( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) installed, run ``` $ npm install @king
Latest version: 1.0.0
Deprecated: see @kingjs/define-symbols

# @[kingjs](https://www.npmjs.com/package/kingjs)/xxx
## Usage
```js
var assert = require('assert');
var xxx = require('@kingjs/xxx');
```
## API
```ts
declare function xxx(
): any
```
### Parameters
### Returns
## Remarks
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/xxx
```
## License
MIT

![Analytics](https://analytics.kingjs.net/xxx)
npm package: @kingjs/loader
Description: ```js var copy = require('@kingjs/xxx'); ``` result: ```js ``` ## API ```ts declare function xxx( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) installed, run ``` $ npm install @kingjs/xxx ``` ## License MIT
Author: Chris King
Latest version: 1.0.2

# @[kingjs](https://www.npmjs.com/package/kingjs)/xxx
## Usage
```js
var copy = require('@kingjs/xxx');
```
result:
```js
```
## API
```ts
declare function xxx(
): any
```
### Parameters
### Returns
## Remarks
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/xxx
```
## License
MIT

![Analytics](https://analytics.kingjs.net/xxx)
npm package: @kingjs/make-enumerable
Description: Make an array enumerable by adding a 'getEnumerable' method.
Author: Chris King
Latest version: 1.0.1
Deprecated: see @kingjs/array.make-enumerable

# @[kingjs](https://www.npmjs.com/package/kingjs)/make-enumerable
Make an array enumerable by adding a `getEnumerable` method.
## Usage
Make an array enumerable like this:
```js
makeEnumerable = require('@kingjs/make-enumerable');
var sequence = makeEnumerable([ 1, 2 ]);

// sequence is still an array...
sequence.push(3); 

// ...that can enumerated!
var enumerator = sequence.getEnumerator();

var result = [];
while (enumerator.moveNext())
  result.push(enumerator.current);
result;
```
result:
```js
[ 1, 2, 3 ]
```
## API
```ts
declare function makeEnumerable(
  array?: Array
): Enumerable
```
### Interfaces
- `Enumerable`: See [@kingjs/sequence](https://www.npmjs.com/package/@kingjs/sequence).
### Parameters
- `array`: The array to augment with function `getEnumerator`.
### Returns
The array passed as `array` augmented with a `getEnumerable` function. 
## Remarks
Passing `null` or `undefined` will return an empty array that is also enumerable.

The array is frozen by the first call to `getEnumerator` to prevent mutating the array during enumeration.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/make-enumerable
```
## License
MIT
npm package: @kingjs/map
Description: Exports all `@kingjs/map.*` functionality in one package.
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/map
Exports all `@kingjs/map.*` functionality in one package.
## Usage
```js
var map = require('@kingjs/map');
```
## API
- [`copy`][copy]
- [`path`][path]
- [`scorch`][scorch]
## Remarks
Mapping functions accept a target object as `this`, mutate the target, and return the target. As such, they can be chained together using [@kingjs/apply](https://www.npmjs.com/package/@kingjs/apply).
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/map
```
## License
MIT

  [copy]: https://www.npmjs.com/package/@kingjs/map.copy
  [path]: https://www.npmjs.com/package/@kingjs/map.path
  [scorch]: https://www.npmjs.com/package/@kingjs/map.scorch
npm package: @kingjs/map.copy
Description: Copies own and inherited enumerable property values optionally skipping those already defined.
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/[map](https://www.npmjs.com/package/@kingjs/map).copy
Copies own and inherited enumerable property values optionally skipping those already defined.
## Usage
Copy properties from `source` to `target` like this:
```js
var copy = require('@kingjs/copy');

var target = { 
  a: 0,
  b: 1, 
};

var source = { 
  b: 2,
  c: 3
};

copy.call(target, source); 
```
result:
```js
{
  a: 0,
  b: 2,
  c: 3
}
```
## API
```ts
declare function copy(
  this, 
  source?, 
  skipIfDefined?: boolean | (name) => boolean,
): any
```
### Parameters
- `this`: An object to which properties are copied.
- `source`: An object whose properties are copied to `this`.
- `skipIfDefined`: Prevent overwriting if:
  - `true`.
  - A function that returns `true` given:
    - `name`: The name of the existing property.
### Returns
Returns `this` after copying properties and values from `source`.
## Remarks
Inherited and own properties are copied. 

Non-enumerable properties are _not_ copied.

if `source` is `null` or `undefined`, then `this` is returned unmodified.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/map.copy
```
## License
MIT
npm package: @kingjs/map.path
Description: Maps an objects property values that are matched by a path.
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/[map](https://www.npmjs.com/package/@kingjs/map).path
Maps an objects property values that are matched by a path.
## Usage
Deduct a dollar from the balances of every account like this:
```js
var mapPath = require('@kingjs/map.path');

var accounts = {
  alice: {
    id: 0,
    balance: 101
  },
  bob: {
    id: 1,
    balance: 201
  }
}

mapPath.call(
  accounts,
  '*.balance',
  function(x) { return x - 1; }
)
```
result:
```js
{
  alice: {
    id: 0,
    balance: 100
  },
  bob: {
    id: 1,
    balance: 200
  }
}
```
## API
```ts
declare function path(
  this,
  path: string | string[],
  callback: (x) => any
): any
```
### Parameters
- `this`: The object whose property's values are mapped.
- `path`: An array of property names and/or the wildcard `'*'` which specify the path(s) to map.
- `callback`: The mapping function to apply to each property that matches the path.
  - `x`: The value of the property being mapped.
### Returns
Returns `this` after mapping properties which matched `path`.
## Remarks
The `path` may also be a `'.'` delimited string composed of property names and/or the wildcard symbol `'*'`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/map.path
```
## License
MIT
npm package: @kingjs/map.scorch
Description: Deletes properties with `undefined` value. 
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/[map](https://www.npmjs.com/package/@kingjs/map).scorch
Deletes properties with `undefined` value. 
## Usage
```js
var scorch = require('@kingjs/scorch');

var source = { a: undefined };
var result = scorch.call(source);
'a' in result;
```
result:
```js
`false`
```
## API
```ts
declare function scorch(
  this: any
): any
```
### Parameters
- `this`: Object whose properties with `undefined` values are to be deleted.
### Returns
Returns `this` after properties with `undefined` value have been deleted.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/map.scorch
```
## License
MIT
npm package: @kingjs/mutate
Description: Exports all `@kingjs/mutate.*` functionality in one package.
Author: Chris King
Latest version: 1.0.6
Deprecated: see @kingjs/descriptor

# @[kingjs](https://www.npmjs.com/package/kingjs)/mutate
Exports all `@kingjs/mutate.*` functionality in one package.
## Usage
```js
var map = require('@kingjs/mutate');
```
## API
- [`merge`][merge]
- [`inherit`][inherit]
- [`path`][path]
- [`scorch`][scorch]
## Remarks
Mutating functions accept a target object as `this`, mutate the target, and return the target. As such, they can be chained together using [@kingjs/apply](https://www.npmjs.com/package/@kingjs/apply).
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/mutate
```
## License
MIT

![Analytics](https://analytics.kingjs.net/mutate)

  [merge]: https://www.npmjs.com/package/@kingjs/mutate.merge
  [inherit]: https://www.npmjs.com/package/@kingjs/mutate.inherit
  [path]: https://www.npmjs.com/package/@kingjs/mutate.path
  [scorch]: https://www.npmjs.com/package/@kingjs/mutate.scorch
npm package: @kingjs/mutate.copy
Description: Copies own and inherited enumerable property values optionally skipping those already defined.
Author: Chris King
Latest version: 1.0.4
Deprecated: see @kingjs/mutate.merge

# @[kingjs](https://www.npmjs.com/package/kingjs)/[mutate](https://www.npmjs.com/package/@kingjs/mutate).copy
Copies own and inherited enumerable property values optionally skipping those already defined.
## Usage
Copy properties from `source` to `target` like this:
```js
var copy = require('@kingjs/mutate.copy');

var target = { 
  a: 0,
  b: 1, 
};

var source = { 
  b: 2,
  c: 3
};

copy.call(target, source); 
```
result:
```js
{
  a: 0,
  b: 2,
  c: 3
}
```
## API
```ts
declare function copy(
  this, 
  source?, 
  skipIfDefined?: boolean | (name) => boolean,
): any
```
### Parameters
- `this`: An object to which properties are copied.
- `source`: An object whose properties are copied to `this`.
- `skipIfDefined`: Prevent overwriting if:
  - `true`.
  - A function that returns `true` given:
    - `name`: The name of the existing property.
### Returns
Returns `this` after copying properties and values from `source`.
## Remarks
Inherited and own properties are copied. 

Non-enumerable properties are _not_ copied.

if `source` is `null` or `undefined`, then `this` is returned unmodified.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/mutate.copy
```
## License
MIT

![Analytics](https://analytics.kingjs.net/mutate/copy)
npm package: @kingjs/mutate.inherit
Description: Copy properties from set of objects which are not present on this.
Author: Chris King
Latest version: 1.0.6
Deprecated: see @kingjs/descriptor.inherit

# @[kingjs](https://www.npmjs.com/package/kingjs)/[mutate](https://www.npmjs.com/package/@kingjs/mutate).inherit
Copy properties from set of objects which are not present on this.
## Usage
Assign default student teacher properties for Alice like this:
```js
var inherit = require('@kingjs/mutate.inherit');

var student = { name: '', ssn: '000-00-0000', credits: 0 };
var teacher = { name: '', ssn: '000-00-0000', pay: 0 };
var alice = { name: 'Alice' };

inherit.call(alice, student, teacher);
```
result:
```js
{
  name: 'Alice',
  ssn: '00-000-0000',
  credits: 0,
  pay: 0,
}
```
## API
```ts
declare function inherit(
  this: any,
  bases: any[]
): any
```
### Parameters
- `this`: Object onto which inherited properties are copied.
- `bases`: An array of objects whose properties will be copied to `this`. 
### Returns
Returns `this` after copying properties from `bases`.
## Remarks
Throws if inherited properties that share the same name do not also have the same value.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/mutate.inherit
```
## License
MIT

![Analytics](https://analytics.kingjs.net/unknown)


  [xxx]: https://www.npmjs.com/package/@kingjs/mutate/inherit
npm package: @kingjs/mutate.merge
Description: Merges own and inherited enumerable property values into `this` using a callback to resolve conflicts.
Author: Chris King
Latest version: 1.0.3
Deprecated: see @kingjs/descriptor.merge

# @[kingjs](https://www.npmjs.com/package/kingjs)/[mutate](https://www.npmjs.com/package/@kingjs/mutate).merge
Merges own and inherited enumerable property values into `this` using a callback to resolve conflicts.
## Usage
Copy properties from `source` to `target` overwriting any existing values like this:
```js
var merge = require('@kingjs/mutate.merge');

var target = { 
  a: 0,
  b: 1, 
};

var source = { 
  b: 2,
  c: 3
};

function resolve(right, left) { 
  return right; 
}

merge.call(target, source, resolve); 

target;
```
result:
```js
{
  a: 0,
  b: 2,
  c: 3
}
```
## API
```ts
declare function merge(
  this, 
  delta?, 
  resolve?: (left, right, name) => any
): any
```
### Parameters
- `this`: An object into which properties are merged.
- `delta`: An object whose properties are merged into `this`.
- `resolve`: Invoked when merging into an existing value. Returns the merged value. If not supplied, then the existing value is taken.
  - `left`: The existing value.
  - `right`: The new value.
  - `name`: The name of the conflicting property.

### Returns
Returns `this` after merging properties from `delta`. 

If `this` is frozen then a copy created via `Object.create` will be created on the first write and returned instead of `this`.
## Remarks
Inherited and own properties are merged; Non-enumerable properties are _not_ merged.

if `delta` is `null` or `undefined`, then `this` is returned unmodified.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/mutate.merge
```
## License
MIT

![Analytics](https://analytics.kingjs.net/mutate/merge)
npm package: @kingjs/mutate.path
Description: Updates property values matched by a path.
Author: Chris King
Latest version: 1.0.7
Deprecated: see @kingjs/descriptor.path

# @[kingjs](https://www.npmjs.com/package/kingjs)/[mutate](https://www.npmjs.com/package/@kingjs/mutate).path
Updates property values matched by a path.
## Usage
Deduct a dollar from the balances of every account like this:
```js
var mapPath = require('@kingjs/mutate.path');

var accounts = {
  alice: {
    id: 0,
    balance: 101
  },
  bob: {
    id: 1,
    balance: 201
  }
}

mapPath.call(
  accounts,
  '*.balance',
  function(x) { return x - 1; }
)
```
result:
```js
{
  alice: {
    id: 0,
    balance: 100
  },
  bob: {
    id: 1,
    balance: 200
  }
}
```
## API
```ts
declare function path(
  this,
  path: string | string[],
  callback: (this, x) => any
): any
```
### Parameters
- `this`: The object whose property's values are updated.
- `path`: An array of property names and/or the wildcard `'*'` which specify the path(s) to map.
- `callback`: The update function to apply to each property that matches the path.
  - `this`: The same this as passed to `path` (which may not be the same as object hosting the property of the value being upated).
  - `x`: The value of the property being updated.
### Returns
Returns `this` after updating properties which matched `path`.
## Remarks
The `path` may also be a `'.'` delimited string composed of property names and/or the wildcard symbol `'*'`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/mutate.path
```
## License
MIT

![Analytics](https://analytics.kingjs.net/mutate/path)
npm package: @kingjs/mutate.scorch
Description: Deletes properties with `undefined` value. 
Author: Chris King
Latest version: 1.0.4
Deprecated: see @kingjs/descriptor.scorch

# @[kingjs](https://www.npmjs.com/package/kingjs)/[mutate](https://www.npmjs.com/package/@kingjs/mutate).scorch
Deletes properties with `undefined` value. 
## Usage
```js
var scorch = require('@kingjs/mutate.scorch');

var source = { a: undefined };
var result = scorch.call(source);
'a' in result;
```
result:
```js
`false`
```
## API
```ts
declare function scorch(
  this: any
): any
```
### Parameters
- `this`: Object whose properties with `undefined` values are to be deleted.
### Returns
Returns `this` after properties with `undefined` value have been deleted.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/mutate.scorch
```
## License
MIT

![Analytics](https://analytics.kingjs.net/mutate/scorch)
npm package: @kingjs/odometer
Description: Generates arrays of odometer digits.
Latest version: 1.0.7

# @[kingjs](https://www.npmjs.com/package/kingjs)/odometer
## Usage
```js
var assert = require('assert');
var odometer = require('@kingjs/odometer');
```
## API
```ts
declare function odometer(
): any
```
### Parameters
### Returns
## Remarks
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/odometer
```
## License
MIT

![Analytics](https://analytics.kingjs.net/odometer)
npm package: @kingjs/package-name.construct
Description: ## Usage ```js var assert = require('assert'); var construct = require('@kingjs/package-name.construct');
Latest version: 1.0.0

# @[kingjs][@kingjs]/[package-name][ns0].[construct][ns1]

## Usage
```js
var assert = require('assert');
var construct = require('@kingjs/package-name.construct');

var together = construct('kingJs', [['Foo', 'Bar'], ['BaZ']]);
assert(together == '@kingjs/foo-bar.baz');

```
## API
```ts
construct(scope, parts)
```
### Parameters
- `scope`: The package scope.
- `parts`: An array of arrays of strings joined with dash then period.
### Returns
Returns the package name.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/package-name.construct
```
## License
MIT

![Analytics](https://analytics.kingjs.net/{path})

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/package-name
[ns1]: https://www.npmjs.com/package/@kingjs/package-name.construct
npm package: @kingjs/package-name.parse
Description: ## Usage ```js var assert = require('assert'); var parse = require('@kingjs/package-name.parse');
Latest version: 1.0.1

# @[kingjs][@kingjs]/[package-name][ns0].[parse][ns1]

## Usage
```js
var assert = require('assert');
var parse = require('@kingjs/package-name.parse');

var apart = parse('@kingjs/foo-bar.baz');
assert(apart.scope == 'kingjs');
assert(apart.fullName == 'foo-bar.baz');

assert(apart.names.length == 2);
assert(apart.names[0] == 'foo-bar');
assert(apart.names[1] == 'baz');

assert(apart.parts.length == 2);
assert(apart.parts[0].length == 2);
assert(apart.parts[1].length == 1);
assert(apart.parts[0][0] == 'foo');
assert(apart.parts[0][1] == 'bar');
assert(apart.parts[1][0] == 'baz');


var apart = parse('foo-bar.baz');
assert(!apart.scope);
assert(apart.fullName == 'foo-bar.baz');

var apart = parse('Bad-Name');
assert(apart === undefined);
```
## API
```ts
parse(name)
```
### Parameters
- `name`: The package name to parse.
### Returns
Returns an AST of literals comprising the package name.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/package-name.parse
```
## License
MIT

![Analytics](https://analytics.kingjs.net/{path})

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/package-name
[ns1]: https://www.npmjs.com/package/@kingjs/package-name.parse
npm package: @kingjs/package-version.construct
Description: Simply join `{ major, minor, patch }` into `'major.minor.patch'`.
Latest version: 1.0.0

# @[kingjs][@kingjs]/[package-version][ns0].[construct][ns1]
Simply join `{ major, minor, patch }` into `'major.minor.patch'`.
## Usage
```js
var assert = require('assert');
var construct = require('@kingjs/package-version.construct');

assert(construct({ 
  major: 1,
  minor: '2',
  patch: 3
}) == '1.2.3');
```

## API
```ts
construct(version)
```

### Parameters
- `version`: An object `{ major, minor, patch }`
### Returns
Return `'major.minor.patch'` corresponding to `version`.


## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/package-version.construct
```

## Source
https://repository.kingjs.net/package-version/construct
## License
MIT

![Analytics](https://analytics.kingjs.net/package-version/construct)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/package-version
[ns1]: https://www.npmjs.com/package/@kingjs/package-version.construct
npm package: @kingjs/package-version.less-than
Description: Compare if one version is less than another.
Latest version: 1.0.0

# @[kingjs][@kingjs]/[package-version][ns0].[less-than][ns1]
Compare if one version is less than another.
## Usage
```js
var assert = require('assert');
var lessThan = require('@kingjs/package-version.less-than');

assert(lessThan('1.2.3', '2.0.0'));
assert(lessThan('1.2.3', '1.3.0'));
assert(lessThan('1.2.3', '1.2.4'));

assert(!lessThan('1.2.3', '1.2.3'));

var major = 1;
var minor = 2;
var patch = 3;
assert(!lessThan({ major, minor, patch }, '1.2.3'));
```

## API
```ts
lessThan(lhs, rhs)
```

### Parameters
- `lhs`: A version string or object of the form `{ major, minor, patch }`.
- `rhs`: A version string or object of the form `{ major, minor, patch }`.
### Returns
Returns `true` if `lhs` is less than `rhs`.


## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/package-version.less-than
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/is`](https://www.npmjs.com/package/@kingjs/is)|`^1.0.9`|
|[`@kingjs/package-version.parse`](https://www.npmjs.com/package/@kingjs/package-version.parse)|`^1.0.0`|
## Source
https://repository.kingjs.net/package-version/less-than
## License
MIT

![Analytics](https://analytics.kingjs.net/package-version/less-than)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/package-version
[ns1]: https://www.npmjs.com/package/@kingjs/package-version.less-than
npm package: @kingjs/package-version.parse
Description: Parse `'major.minor.version'` into `{ major, minor, version }`.
Latest version: 1.0.1

# @[kingjs][@kingjs]/[package-version][ns0].[parse][ns1]
Parse `'major.minor.version'` into `{ major, minor, version }`.
## Usage
```js
var assert = require('assert');
var parse = require('@kingjs/package-version.parse');

assert.deepEqual({
  major: 1,
  minor: 2,
  patch: 3
}, parse('1.2.3'));
```

## API
```ts
parse(version)
```

### Parameters
- `version`: A version string typically taken from `package.json`.
### Returns
Returns `{ major, minor, version }` where the fields are numbers parsed from `version`.


## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/package-version.parse
```

## Source
https://repository.kingjs.net/package-version/parse
## License
MIT

![Analytics](https://analytics.kingjs.net/package-version/parse)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/package-version
[ns1]: https://www.npmjs.com/package/@kingjs/package-version.parse
npm package: @kingjs/parse-source
Description: Expresses a TypeScript AST as an object literal.
Latest version: 1.0.0

# @[kingjs][@kingjs]/[parse-source][ns0]
Expresses a TypeScript AST as an object literal.
## Usage
```js
var assert = require('assert');
var parseSource = require('@kingjs/parse-source');

var ast = parseSource(__filename, { 
  type: true, 
  lines: true,
  character: true
});

var { 
  SourceFile,
  VariableStatement,
  VariableDeclaration,
  CallExpression
} = parseSource;

assert(ast instanceof SourceFile);

var statement = ast.statements[0];
assert(statement instanceof VariableStatement);

var declaration = statement.declarationList[0];
assert(declaration instanceof VariableDeclaration);
assert(declaration.name == 'assert');

var callExpression = declaration.initializer;
assert(callExpression instanceof CallExpression);
assert(callExpression.expression == 'require');
assert(callExpression.arguments[0] == 'assert');

var json = JSON.stringify(ast, null, 2);
console.log(json);
```

## API
```ts
parse(path, options)
```

### Parameters
- `path`: Path to file to a file to parse.
- `options`: Options to add type, and positioning information to AST.
- `options.type`: If true, type information is added to the AST as `.` properties so it'll appear if the AST is serialized to JSON.
- `options.line`: If true, line numbers are added to the AST.
- `options.character`: If true, character position is added to the AST.
### Returns
Each node of the Typescript AST is stripped down to just those properties that return nodes or are terminal literals.


## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/parse-source
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/reflect.is`](https://www.npmjs.com/package/@kingjs/reflect.is)|`^1.0.1`|
|[`typescript`](https://www.npmjs.com/package/typescript)|`^3.2.4`|
## Source
https://repository.kingjs.net/parse-source
## License
MIT

![Analytics](https://analytics.kingjs.net/parse-source)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/parse-source
npm package: @kingjs/polymorphisms
Description: Declared on functions, provides an object declaring symbols for polymorphisms of the function's instances.
Latest version: 1.0.5
Deprecated: see @kingjs/symbol

# @[kingjs](https://www.npmjs.com/package/kingjs)/polymorphisms
Declared on functions, provides an object declaring symbols for polymorphisms of the function's instances.
## Usage
Publish the fact that `FooBar` implements `IFoo` and `IBar` like this:
```js
var polymorphismsId = require('@kingjs/polymorphisms');
var identityId = require('@kingjs/identity');

function IFoo() { }
IFoo.prototype = null;
var IFooId = IFoo[identityId] = Symbol('IFoo')
IFoo.foo = Symbol('foo');

function IBar() { }
IBar.prototype = null;
var IBarId = IBar[identityId] = Symbol('IBar')
IBar.bar = Symbol('bar');

function FooBar() { }
FooBar.prototype[IFoo.foo] = 'foo';
FooBar.prototype[IBar.bar] = 'bar';
FooBar[polymorphismsId] = {
  [IFoo[identityId]]: IFoo,
  [IBar[identityId]]: IBar,
}

var isIFoo = IFooId in FooBar[polymorphismsId]; // true
var isIBar = IBarId in FooBar[polymorphismsId]; // true
```
## See Also
- `Identity`: see [@kingjs/identity][identity]
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/polymorphisms
```
## License
MIT

![Analytics](https://analytics.kingjs.net/polymorphisms)

[identity]: https://www.npmjs.com/package/@kingjs/identity
npm package: @kingjs/poset
Description: Exposes @kingjs.poset.*
Author: Chris King
Latest version: 1.0.7

# @[kingjs](https://www.npmjs.com/package/kingjs)/poset
Exports all `@kingjs/poset.*` functionality in one package.
## Usage
```js
var poset = require('@kingjs/poset');
```
## Interfaces
```ts
declare interface EncodedPoset {
  [index: string]: any
}
```
A descriptor whose every property name is a concatenation of a vertex name and its adjacent vertices' names delimited by `$`, and whose every property value contains the properties of the corresponding vertex.
```ts
declare interface AdjacencyList {
  [index: string]: string[]
}
```
A descriptor whose every property name represents a named vertex and whose every property value is an array containing the names of the associated vertices' values.

A vertex found in an adjacency list that has no corresponding property of the same name on the descriptor is still a valid and is simply assumed to have no outbound edges.
```ts
declare interface VertexProperties {
  [index: string]: any
}
```
A descriptor whose every property name a vertex name, and whose every property value contains the properties of the corresponding vertex.
## API
- [`decode`][decode]
- [`encode`][encode]
- [`forEach`][for-each]
- [`inherit`][inherit]
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/poset
```
## License
MIT

![Analytics](https://analytics.kingjs.net/poset)

  [decode]: https://www.npmjs.com/package/@kingjs/poset.decode
  [encode]: https://www.npmjs.com/package/@kingjs/poset.encode
  [for-each]: https://www.npmjs.com/package/@kingjs/poset.for-each
  [inherit]: https://www.npmjs.com/package/@kingjs/poset.inherit
npm package: @kingjs/poset.decode
Description: Decodes a descriptor representing a poset into an adjacency list and a vertex property map.
Author: Chris King
Latest version: 1.0.10

# @[kingjs](https://www.npmjs.com/package/kingjs)/[poset][poset].decode
Decodes a descriptor representing a poset into an adjacency list and a vertex property map.

## Usage
Decode an encoded [poset](https://en.wikipedia.org/wiki/Partially_ordered_set) with exported vertices `'a'`, `'b'`, and `'c'` where vertex `'a'` has value `1`, and depends on vertices `'b'` and `'c'` which have values `2` and `3` respectively, and both depend on `'d'` which has value `4`, like this:
```js
var decode = require('@kingjs/poset.decode');

var vertices = { };
//   a=1
//   / \
// b=2 c=3
//   \ /
//   d=4
var result = {
  edges: decode.call({
    a$b$c: 1,
    b$d: 2,
    c$d: 3,
    d: 4,
  }, vertices),
  
  vertices: vertices
}
```
result:
```js
{
  edges: {
    a: [ 'b', 'c' ],
    b: [ 'd' ],
    c: [ 'd' ]
  },

  vertices: {
    a: 1,
    b: 2,
    c: 3,
    d: 4
  }
}
```
## API
```ts
declare function decode(
  this: EncodedPoset,
  vertices: VertexProperties
): AdjacencyList
```
### Interfaces
- `EncodedPoset`: see [@kingjs/poset][poset]
- `VertexProperties`: see [@kingjs/poset][poset]
- `AdjacencyList`: see [@kingjs/poset][poset]
### Parameters
- `this`: An encoded poset.
- `vertices`: A out descriptor augmented with vertex properties.
### Returns
An descriptor with a property for every vertex that has adjacent vertices. Each property value is an array of names of the adjacent vertices. 
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/poset.decode
```
## License
MIT

![Analytics](https://analytics.kingjs.net/poset/decode)

  [poset]: https://www.npmjs.com/package/@kingjs/poset
npm package: @kingjs/poset.encode
Description: Encodes an adjacency list and vertex property map into a descriptor whose property names, when split on `$`, reveal a vertex name followed by its adjacent vertices, and whose property values correspond to vertex properties.
Author: Chris King
Latest version: 1.0.8

# @[kingjs](https://www.npmjs.com/package/kingjs)/[poset][poset].encode
Encodes properties of vertices and their adjacent vertices into a descriptor.
## Usage
Encode a [poset](https://en.wikipedia.org/wiki/Partially_ordered_set) where vertex `'a'` has value `1` and depends on `'b'` and `'c'` which have values `2` and `3` respectively, and both depend on `'d'` which has value `4`, like this:
```js
var encode = require('@kingjs/poset.encode');

//   a=1
//   / \
// b=2 c=3
//   \ /
//   d=4
encode.call({
  a: [ 'b', 'c' ],
  b: [ 'd' ],
  c: [ 'd' ],
}, {
  a: 1,
  b: 2,
  c: 3,
  d: 4
});
```
result:
```js
{
  a$b$c: 1,
  b$d: 2,
  c$d: 3,
  d: 4,
}
```
## API
```ts
declare function encode(
  this: AdjacencyList,
  vertices: VertexProperties
): EncodedPoset
```
### Interfaces
- `EncodedPoset`: see [@kingjs/poset][poset]
- `VertexProperties`: see [@kingjs/poset][poset]
- `AdjacencyList`: see [@kingjs/poset][poset]
### Parameters
- `this`: A descriptor whose properties are vertex names and whose values are vertex properties.
- `edges`: A descriptor whose properties are vertex names and whose values are arrays containing the names of adjacent vertices.
### Returns
Returns a descriptor whose every property name is a join by `'$'` of a vertex name followed by its adjacent vertices.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/poset.encode
```
## License
MIT

![Analytics](https://analytics.kingjs.net/poset/encode)

  [poset]: https://www.npmjs.com/package/@kingjs/poset