open-index/open-npm huggingface dataset:
npm package: @kingjs/func.return-arg-0
Description: A function that returns the first argument.
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/[func](https://www.npmjs.com/package/func).return-arg-0
A function that returns the first argument.
## Usage
Return the first argument like this:
```js
var returnArg0 = require('@kingjs/func.return-arg-0');

returnArg0('Hello World!');
```
result:
```js
'Hello World!'
```
## API
```ts
declare function returnArg0(
  arg0: any
): any
```
### Parameters
- `arg0`: Any value.
### Returns
Returns `arg0`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/func.return-arg-0
```
## License
MIT

![Analytics](https://analytics.kingjs.net/func/return-arg-0)
npm package: @kingjs/func.return-arg-1
Description: A function that returns the second argument.
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/[func](https://www.npmjs.com/package/func).return-arg-1
A function that returns the second argument.
## Usage
Return the second argument like this:
```js
var returnArg1 = require('@kingjs/func.return-arg-1');

returnArg1('Hello', 'World!');
```
result:
```js
'World!'
```
## API
```ts
declare function returnArg1(
  arg0: any,
  arg1: any
): any
```
### Parameters
- `arg0`: Any value.
- `arg1`: Any value.
### Returns
Returns `arg1`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/func.return-arg-1
```
## License
MIT

![Analytics](https://analytics.kingjs.net/func/return-arg-1)
npm package: @kingjs/func.return-this
Description: A function that returns this.
Author: Chris King
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/[func](https://www.npmjs.com/package/func).return-this
A function that returns `this`.
## Usage
Return `this` like this:
```js
var returnThis = require('@kingjs/func.return-this');

returnThis.call('Hello World!');
```
result:
```js
'Hello World!'
```
## API
```ts
declare function returnThis(
  this: any
): any
```
### Parameters
- `this`: Any value.
### Returns
Returns `this`.
## Remarks
If `this` is a primitive value, then `returnThis` will return a boxed version of the primitive value.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/func.return-this
```
## License
MIT

![Analytics](https://analytics.kingjs.net/func/return-this)
npm package: @kingjs/function-ex.rename
Description: Renames a function.
Latest version: 1.0.2

# @[kingjs][@kingjs]/[function-ex][ns0].[rename][ns1]
Renames a function.
## Usage
```js
var assert = require('assert');
var Rename = require('@kingjs/function-ex.rename');

function foo() { }
var fooDescriptor = Object.getOwnPropertyDescriptor(foo, 'name');
assert(fooDescriptor.value == 'foo');

var bar = foo[Rename]('bar');
var barDescriptor = Object.getOwnPropertyDescriptor(foo, 'name');
assert(barDescriptor.value == 'bar');
assert(barDescriptor.enumerable == fooDescriptor.enumerable);
assert(barDescriptor.configurable == fooDescriptor.configurable);
assert(barDescriptor.writable == fooDescriptor.writable);

```

## API
```ts
rename(this, string)
```
### Parameters
- `this`: The function to rename.
- `string`: The name to assign the function.
### Returns
Returns the function.

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/function-ex.rename
```
## Source
https://repository.kingjs.net/function-ex/rename
## License
MIT

![Analytics](https://analytics.kingjs.net/function-ex/rename)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/function-ex
[ns1]: https://www.npmjs.com/package/@kingjs/function-ex.rename
npm package: @kingjs/generator
Description: The constructor for generator functions.
Author: Chris King
Latest version: 1.0.1

# @[kingjs][@kingjs]/[generator][ns0]
The constructor for generator functions.






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

## Source
https://repository.kingjs.net/generator
## License
MIT

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/generator
npm package: @kingjs/get-own-property-keys
Description: Returns own property names and symbols in an array.
Latest version: 1.0.0
Deprecated: See Reflect.ownKeys

# @[kingjs][@kingjs]/[get-own-property-keys][ns0]
Returns own property names and symbols in an array.
## Usage
```js
var assert = require('assert');
var getOwnPropertyKeys = require('@kingjs/get-own-property-keys');

var symbol = Symbol();
var name = 'name';

var keys = getOwnPropertyKeys.call({ 
  [symbol]: null,
  [name]: null
});

assert.deepEqual(keys, [name, symbol]);
```

## API
```ts
getOwnPropertyKeys(this)
```
### Parameters
- `this`: The object whose own property names and symbols will be returned.
### Returns
Returns own property names and symbols in an array.

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/get-own-property-keys
```
## Source
https://repository.kingjs.net/get-own-property-keys
## License
MIT

![Analytics](https://analytics.kingjs.net/get-own-property-keys)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/get-own-property-keys
npm package: @kingjs/git.get-dir
Description: Returns the git root directory.
Latest version: 1.0.0

# @[kingjs][@kingjs]/[git][ns0].[get-dir][ns1]
Returns the git root directory.
## Usage
```js
var assert = require('assert');
var getDir = require('@kingjs/git.get-dir');

console.log(getDir());

var gitFoo = getDir('foo');
console.log(gitFoo);

```

## API
```ts
getDir([subDir])
```
### Parameters
- `subDir`: A sub-directory to join to the git root directory.
### Returns
Returns the git root directory.

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/git.get-dir
```
## Source
https://repository.kingjs.net/git.get-dir
## License
MIT

![Analytics](https://analytics.kingjs.net/git/get-dir)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/git
[ns1]: https://www.npmjs.com/package/@kingjs/git.get-dir
npm package: @kingjs/has-instance
Description: Symbol.hasInstance implementation that tests for a function's id in an instance's polymorphisms.
Latest version: 1.0.10
Deprecated: see @define-interface

# @[kingjs](https://www.npmjs.com/package/kingjs)/has-instance
`Symbol.hasInstance` implementation that tests for a function's id in an instance's polymorphisms.
## Usage
Test that `FooBar` implements `IFoo` and `IBar` using `instanceof` operator like this:
```js
var hasInstance = require('@kingjs/has-instance');
var assert = require('assert')

var Identity = Symbol.for('@kingjs/Identity');
var Polymorphisms = Symbol.for('@kingjs/Polymorphisms');

function IFoo() { }
IFoo.prototype = null;
IFoo[Identity] = Symbol('IFoo')
IFoo.foo = Symbol('foo');
Object.defineProperty(IFoo, Symbol.hasInstance, { value: hasInstance });

function IBar() { }
IBar.prototype = null;
IBar[Identity] = Symbol('IBar')
IBar.bar = Symbol('bar');
Object.defineProperty(IBar, Symbol.hasInstance, { value: hasInstance });

function FooBar() { }
FooBar.prototype[IFoo.foo] = 'foo';
FooBar.prototype[IBar.bar] = 'bar';
FooBar[Polymorphisms] = {
  [IFoo[Identity]]: IFoo,
  [IBar[Identity]]: IBar,
}

var fooBar = new FooBar();
var isIFoo = fooBar instanceof IFoo;
var isIBar = fooBar instanceof IBar;

assert(isIFoo);
assert(isIBar);
```
## See Also
- `Identity`: see [@kingjs/identity][identity]
- `Polymorphisms`: see [@kingjs/polymorphisms][polymorphisms]
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/has-instance
```
## License
MIT

![Analytics](https://analytics.kingjs.net/has-instance)

[identity]: https://www.npmjs.com/package/@kingjs/identity
[polymorphisms]: https://www.npmjs.com/package/@kingjs/polymorphisms
npm package: @kingjs/i-enumerable
Description: `IEnumerable` has a single member `getEnumerator`.
Latest version: 1.0.8

# @[kingjs][@kingjs]/[i-enumerable][ns0]
`IEnumerable` has a single member `getEnumerator`.
## Usage
```js
var assert = require('assert');
var IInterface = require('@kingjs/i-interface');
var IEnumerable = require('@kingjs/i-enumerable');

var id = Symbol.for('@kingjs/IEnumerable.getEnumerator');

assert(IEnumerable instanceof Function);
assert(IEnumerable.name == '@kingjs/IEnumerable');

assert(IEnumerable.getEnumerator == id);
assert(IEnumerable.GetEnumerator == id);
assert(IEnumerable instanceof IInterface);
```





## See Also
- [`@kingjs/reflect.implement-interface`][ImplementInterface]
- [`@kingjs/i-enumerator`][IEnumerator]

[IEnumerator]: https://www.npmjs.com/package/@kingjs/i-enumerator
[ImplementInterface]: https://www.npmjs.com/package/@kingjs/reflect.implement-interface

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/i-enumerable
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/reflect.create-interface`](https://www.npmjs.com/package/@kingjs/reflect.create-interface)|`^1.0.4`|
## Source
https://repository.kingjs.net/i-enumerable
## License
MIT

![Analytics](https://analytics.kingjs.net/i-enumerable)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/i-enumerable
npm package: @kingjs/i-enumerator
Description: `IEnumerator` has members `current` and `moveNext`.
Latest version: 1.0.8

# @[kingjs][@kingjs]/[i-enumerator][ns0]
`IEnumerator` has members `current` and `moveNext`.
## Usage
```js
var assert = require('assert');
var IInterface = require('@kingjs/i-interface');
var IEnumerator = require('@kingjs/i-enumerator');

var MoveNext = Symbol.for('@kingjs/IEnumerator.moveNext');
var Current = Symbol.for('@kingjs/IEnumerator.current');

assert(IEnumerator instanceof Function);
assert(IEnumerator.name == '@kingjs/IEnumerator');

assert(IEnumerator.MoveNext == MoveNext);
assert(IEnumerator.Current == Current);
assert(IEnumerator instanceof IInterface);
```





## See Also
- [`@kingjs/reflect.implement-interface`][ImplementInterface]
- [`@kingjs/i-enumerable`][IEnumerable]

[IEnumerable]: https://www.npmjs.com/package/@kingjs/i-enumerable
[ImplementInterface]: https://www.npmjs.com/package/@kingjs/reflect.implement-interface

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/i-enumerator
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/reflect.create-interface`](https://www.npmjs.com/package/@kingjs/reflect.create-interface)|`^1.0.4`|
## Source
https://repository.kingjs.net/i-enumerator
## License
MIT

![Analytics](https://analytics.kingjs.net/i-enumerator)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/i-enumerator
npm package: @kingjs/i-identifiable
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.0
Deprecated: see @Kingjs/symbol

# @[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/i-interface
Description: IInterface.Id is found on functions representing interfaces and stores the symbol identifying the interface.
Latest version: 1.0.4

# @[kingjs][@kingjs]/[i-interface][ns0]
IInterface.Id is found on functions representing interfaces and stores the symbol identifying the interface.
## Usage
```js
var assert = require('assert');

// an interface, in the abstract, is just 
// a symbolic name representing a collection 
// of of symbols (just one in this case).
var Id = Symbol.for('@kingjs/IInterface.id');

// the name and symbol collection are 
// gathered onto an abstract function
var IInterface = require('@kingjs/i-interface');
assert(IInterface instanceof Function);
assert(IInterface.prototype == null);
assert(IInterface.constructor == null);
assert.throws(() => new IInterface);

// the identifying symbol is stored in Id on the function
assert(IInterface[Id] == Id);

// the reason a function is used as the 
// underlying object representing interfaces
// is so that instances can be tested to
// see if they implement an interface
assert(Symbol.hasInstance in IInterface);

// It's mind bending, but the function 
// itself is an instance implementing IInterface
assert(IInterface instanceof IInterface);
```






## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/i-interface
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/reflect.create-interface`](https://www.npmjs.com/package/@kingjs/reflect.create-interface)|`^1.0.0`|
## Source
https://repository.kingjs.net/i-interface
## License
MIT

![Analytics](https://analytics.kingjs.net/i-interface)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/i-interface
npm package: @kingjs/i-iterable
Description: `IIterable` has one member `getIterator`.
Latest version: 1.0.3

# @[kingjs][@kingjs]/[i-iterable][ns0]
`IIterable` has one member `getIterator`.
## Usage
```js
var assert = require('assert');
var IIterable = require('@kingjs/i-iterable');

var Id = Symbol.iterator;
var IInterfaceId = Symbol.for('@kingjs/IInterface.id');

assert(IIterable.name == '@kingjs/IIterable');
assert(IIterable[IInterfaceId] == Id);
assert([] instanceof IIterable);
assert('' instanceof IIterable);
```






## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/i-iterable
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/reflect.create-interface`](https://www.npmjs.com/package/@kingjs/reflect.create-interface)|`^1.0.2`|
## Source
https://repository.kingjs.net/i-iterable
## License
MIT

![Analytics](https://analytics.kingjs.net/i-iterable)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/i-iterable
npm package: @kingjs/i-ordered-enumerable
Description: `IOrderedEnumerable` extends `IEnumerable` with  a single member  `createOrderedEnumerable`.
Latest version: 1.0.8

# @[kingjs][@kingjs]/[i-ordered-enumerable][ns0]
`IOrderedEnumerable` extends `IEnumerable` with  a single member  `createOrderedEnumerable`.
## Usage
```js
var assert = require('assert');
var IInterface = require('@kingjs/i-interface');
var IEnumerable = require('@kingjs/i-enumerable');
var IOrderedEnumerable = require('@kingjs/i-ordered-enumerable');

var id = Symbol.for('@kingjs/IOrderedEnumerable.createOrderedEnumerable');

assert(IOrderedEnumerable instanceof Function);
assert(IOrderedEnumerable.name == '@kingjs/IOrderedEnumerable');

assert(IOrderedEnumerable.getEnumerator == IEnumerable.getEnumerator);
assert(IOrderedEnumerable.GetEnumerator == IEnumerable.getEnumerator);
assert(IOrderedEnumerable.createOrderedEnumerable == id);
assert(IOrderedEnumerable instanceof IInterface);
```





## See Also
- [`@kingjs/reflect.implement-interface`][ImplementInterface]
- [`@kingjs/i-enumerator`][IEnumerator]

[IEnumerator]: https://www.npmjs.com/package/@kingjs/i-enumerator
[ImplementInterface]: https://www.npmjs.com/package/@kingjs/reflect.implement-interface

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/i-ordered-enumerable
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/i-enumerable`](https://www.npmjs.com/package/@kingjs/i-enumerable)|`latest`|
|[`@kingjs/reflect.create-interface`](https://www.npmjs.com/package/@kingjs/reflect.create-interface)|`latest`|
## Source
https://repository.kingjs.net/i-ordered-enumerable
## License
MIT

![Analytics](https://analytics.kingjs.net/i-ordered-enumerable)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/i-ordered-enumerable
npm package: @kingjs/i-polymorphic
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.0
Deprecated: see @kingjs/symbol

# @[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/identity
Description: A symbol used to store an identifying symbol on an object.
Latest version: 1.0.6
Deprecated: see @kingjs/symbol

# @[kingjs](https://www.npmjs.com/package/kingjs)/identity
A symbol used to store an identifying symbol on an object.
## Usage
```js
var identityId = require('@kingjs/identity');
function Foo() { }
Foo[identityId] = Symbol('Foo');
```
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/identity
```
## License
MIT

![Analytics](https://analytics.kingjs.net/identity)
npm package: @kingjs/immutable
Description: Exports all `@kingjs/immutable.*` functionality in one package.
Author: Chris King
Latest version: 1.0.2
Deprecated: see @kingjs/descriptor.nested

# @[kingjs](https://www.npmjs.com/package/kingjs)/immutable
Exports all `@kingjs/immutable.*` functionality in one package.
## Usage
```js
var immutable = require('@kingjs/immutable');
```
## API
- [`copy`][copy]
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/immutable
```
## License
MIT

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

  [copy]: https://www.npmjs.com/package/@kingjs/immutable.copy
npm package: @kingjs/immutable.copy
Description: Clone target tree and update its values with a subtree of source tree which have matching paths in the action tree.
Author: Chris King
Latest version: 1.0.1
Deprecated: see @kingjs/descriptor.nested.merge

# @[kingjs](https://www.npmjs.com/package/kingjs)/[immutable](https://www.npmjs.com/package/@kingjs/immutable).copy
Clone target tree and update its values with a subtree of source tree which have matching paths in the action tree.
## Usage
Flip `a0` and `b0` property values from `0` to `1` like this:
```js
var copy = require('@kingjs/immutable.copy');

var target = {
  a0: 0,
  a1: 0,
  a2: 0,
  a3: { b0: 0 },
  a4: { b0: 0, b1: 0, b2: 0 },
  a5: { b0: 0 }
};

var source = { 
  a0: 1,
  a1: 1,
  a3: { b0: 1 },
  a4: { b0: 1, b1: 1 }
};

var action = {
  a0: null,
  a2: null,
  a4: { b0: null, b2: null },
  a5: { b0: null }
};

copy(target, source, action);
```
result:
```js
{
  a0: 1,
  a1: 0,
  a2: 0,
  a3: { b0: 0 },
  a4: { b0: 1, b1: 0, b2: 0 },
  a5: { b0: 0 }
}
```
## API
```ts
declare function augment(
  target: Descriptor,
  source: Descriptor,
  action: Descriptor
): Descriptor
```
### Interfaces
- `Descriptor`: see [@kingjs/descriptor][descriptor]
### Parameters
- `target`: Descriptor tree to which properties from corresponding `source` paths are copied if a corresponding `action` path exists. Paths are cloned and created as needed.
- `source`: Descriptor tree from which properties are copied to corresponding `target` paths if a corresponding `action` path exists.
- `action`: Descriptor tree of functions to combine corresponding property values of `target` and `source` before being copied to a clone of `target`.
### Returns
Returns a clone of `target` tree with values copied from `source` tree if those values share paths on `action`.
## Remarks
Imagine `target`, `source`, and `action` as directories of values where a directory is a `descriptor`. 

Each value in `source` is copied to its corresponding directory in `target` but only if there is also a corresponding value in `action`. 

Intermediate directories are created or cloned as needed.

A value is overwritten if it's `undefined` or preserved if the `source` value is `undefined`. When neither are `undefined` then, if there is a function at the corresponding `action` directory, that function is used to create the updated value given the values from `this` and `source`. If no function is found at `action` then the value is overwritten with the `source` value.

Exceptions are thrown if the following invariants are violated:
- `action` contains a value that is not `null`, `undefined`, or a function.
- A directory in `action` is found to be a value in either `this` or `source`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/immutable.copy
```
## License
MIT

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


  [descriptor]: https://www.npmjs.com/package/@kingjs/descriptor
npm package: @kingjs/is
Description: ```js var copy = require('@kingjs/is'); ``` result: ```js ``` ## API ```ts declare function is( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) installed, run ``` $ npm install @kingjs/is ``` #
Author: Chris King
Latest version: 1.0.9

# @[kingjs][kingjs]/is
## Usage
```js
var copy = require('@kingjs/is');
```
result:
```js
```
## API
```ts
declare function is(
): any
```
### Parameters
### Returns
## Remarks
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/is
```
## License
MIT

![Analytics](https://analytics.kingjs.net/is)

[kingjs]: https://www.npmjs.com/package/kingjs
npm package: @kingjs/is-enumerable
Description: Returns true if own or inherited property is enumerable.
Author: Chris King
Latest version: 1.0.1
Deprecated: see @kingjs/create-interface

# @[kingjs](https://www.npmjs.com/package/kingjs)/is-enumerable
Returns true if own or inherited property is enumerable.
## Usage
Test if an inherited override of `toString` is enumerable like this:
```js
var isEnumerable = require('@kingjs/is-enumerable');

isEnumerable.call(Object.create({ toString: null }), 'toString');
```
result:
```js
true
```
## API
```ts
declare function isEnumerable(
  this,
  name: string
): boolean
```
### Parameters
- `this`: The object to test for an enumerable property.
- `name`: The property name to test.
### Returns
Returns `true` if the own or inherited property `name` exists and is enumerable, otherwise `false`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/is-enumerable
```
## License
MIT

![Analytics](https://analytics.kingjs.net/is-enumerable)
npm package: @kingjs/is-object
Description: Returns true if the `typeof` a value is `'object'` and is not `null`
Author: Chris King
Latest version: 1.0.1

# @[kingjs](https://www.npmjs.com/package/kingjs)/is-object
Returns true if the `typeof` a value is `'object'` and is not `null`.
## Usage
Test if `undefined`, `10`, `null`, `'Hi!'`, `function() { }`, `[]`, `{ }` are objects like this: 
```js
var isObject = require('@kingjs/is-object');

{
  undef: isObject(),
  nll: isObject(null),
  number: isObject(10),
  string: isObject('Hi!'),
  func: isObject(function() { }),
  array: isObject([ ]), 
  literal: isObject({ }), 
}
```
result:
```js
{
  undef: false,
  nll: false,
  number: false,
  string: false,
  func: false,
  array: true, 
  literal: true, 
}
```
## API
```ts
declare function isObject(
  value: any
): boolean
```
### Parameters
- `value`: The value to test.
### Returns
Returns true if the type of the value is object and the value is not null.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/is-object
```
## License
MIT

![Analytics](https://analytics.kingjs.net/is-object)
npm package: @kingjs/js
Description: js
Author: Chris King
Latest version: 1.0.20

# @kingjs/js Library
Here is a [blurb](docs/theIdea.md) describing the impetus for the library.

## APIs

[`mapDescriptors`](docs/mapDescriptors.md): A function for transforming Javascript object literals. 

For example, compiling (transforming) a Domain Specific Languages grafted on top of Javascript object literal syntax into Javascript classes.

[`defineProperty wrappers`](docs/defineProperty.md): A function for transforming Javascript object literals.

Functions for creating property descriptors with a given configuration specific for that type. For example, `defineHiddenAccessor` creates a non-enumerable, non-configurable property with a `get` accessor.
npm package: @kingjs/linq.aggregate
Description: Applies an accumulator function over a sequence.  The specified seed value is used as the initial accumulator value,  and the specified function is used to select the result value.
Author: Chris King
Latest version: 1.0.21

# @[kingjs][@kingjs]/[linq][ns0].[aggregate][ns1]
Applies an accumulator function over a sequence.  The specified seed value is used as the initial accumulator value,  and the specified function is used to select the result value.
## Usage
```js
require('kingjs');
var assert = require('assert');
var Aggregate = require('@kingjs/linq.aggregate');

var sequence = [2, 3, 4];

var result = sequence[Aggregate](1, function(x) {
  return this + x; 
}, o => String(o));

assert(result === '10');
```

## API
```ts
aggregate(this, seed, aggregator, selector)
```

### Parameters
- `this`: An `IEnumerable` over which to aggregate.
- `seed`: The initial accumulator value.
- `aggregator`: An accumulator function to be invoked on each element.
- `selector`: A function to transform the final accumulator value  into the result value.
### Returns
The transformed final accumulator value.


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

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/linq
[ns1]: https://www.npmjs.com/package/@kingjs/linq.aggregate
npm package: @kingjs/linq.all
Description: Returns true if all elements of a sequence satisfy a condition.
Author: Chris King
Latest version: 1.0.12

# @[kingjs][@kingjs]/[linq][ns0].[all][ns1]
Returns true if all elements of a sequence satisfy a condition.
## Usage
```js
require('kingjs');
var assert = require('assert');
var All = require('@kingjs/linq.all');

var sequence = [0, 1, 2];

assert(sequence[All](function(o) { return o < 3; }));
assert(!sequence[All](function(o) { return o < 2; }));
```

## API
```ts
all(this, predicate)
```

### Parameters
- `this`: An IEnumerable that contains the elements to which the predicate will be applied.
- `predicate`: A function to test each element for a condition.
### Returns
`true` if every element of the source sequence passes the test in the  specified predicate, or if the sequence is empty; otherwise, `false`.


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

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/linq
[ns1]: https://www.npmjs.com/package/@kingjs/linq.all
npm package: @kingjs/linq.any
Description: Returns true if any element of a sequence satisfies a condition.
Author: Chris King
Latest version: 1.0.11

# @[kingjs][@kingjs]/[linq][ns0].[any][ns1]
Returns true if any element of a sequence satisfies a condition.
## Usage
```js
require('kingjs');
var assert = require('assert');
var Any = require('@kingjs/linq.any');

var sequence = [0, 1, 2];

assert(sequence[Any]());
assert(sequence[Any](function(o) { return o == 1; }));
assert(!sequence[Any](function(o) { return o == 3; }));
```

## API
```ts
any(this[, predicate])
```

### Parameters
- `this`: An IEnumerable that contains the elements to which the predicate will be applied.
- `predicate`: A function to test each element for a condition.
### Returns
`true` if any elements in the source sequence pass the test  in the specified predicate; otherwise, `false`.


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

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/linq
[ns1]: https://www.npmjs.com/package/@kingjs/linq.any
npm package: @kingjs/linq.append
Description: Generates an sequence identical to another sequence but with a value added to the end.
Author: Chris King
Latest version: 1.0.6

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).append
Generates an sequence identical to another sequence but with a value added to the end.
## Usage
Append `3` to the sequence `0`, `1`, `2` like this:

```js
var append = require('@kingjs/linq.append');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var enumerable = sequence(0, 1, 2);

var result = append.call(enumerable, 3);

toArray.call(result);
```
result:
```js
[0, 1, 2, 3]
```
## API
```ts
declare function append(
  this: Enumerable,
  value
): Enumerable
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: A sequence of values. 
- `value`: The value to append.

### Return Value
Returns a sequence with `value` appended.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.append
```

## Acknowledgments
Like [Enumerable.Append](https://msdn.microsoft.com/en-us/library/mt823360(v=vs.110).aspx)

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/append)
npm package: @kingjs/linq.average
Description: Returns the average value of a sequence of numbers projected from elements of a sequence.
Author: Chris King
Latest version: 1.0.11

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).average
Returns the average value of a sequence of numbers projected from elements of a sequence.
## Usage
Compute the average of `[-2, 0, 2]` like this:
```js
var average = require('@kingjs/linq.average');
var sequence = require('@kingjs/enumerable.create');

average.call(sequence(-2, 0, 2));
```
result:
```js
0
```

## API
```ts
declare function average(
  this: Enumerable,
  selector?: function(x): number
): number
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: The sequence of numbers to average.
- `selector`: A function to select a number from each element.

### Return Value
The average value of the sequence of numbers. Returns `NaN` if the sequence is empty.

## Remarks
Elements are summed using the `+` operator.

Average of an empty sequence is `NaN`.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.average
```
## See Also
Like [Enumerable.Average](https://msdn.microsoft.com/en-us/library/bb358946(v=vs.110).aspx)

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/average)
npm package: @kingjs/linq.concat
Description: Concatenates two sequences.
Author: Chris King
Latest version: 1.0.10

# @[kingjs][@kingjs]/[linq][ns0].[concat][ns1]
Concatenates two sequences.
## Usage
```js
require('kingjs')

var assert = require('assert');

var Concat = require('@kingjs/linq.concat');
var { GetEnumerator } = require('@kingjs/i-enumerable');
var { MoveNext, Current } = require('@kingjs/i-enumerator');

var result = [0, 1][Concat]([1, 2]);

var enumerator = result[GetEnumerator]();
assert(enumerator[MoveNext]());
assert(enumerator[Current] == 0);

assert(enumerator[MoveNext]());
assert(enumerator[Current] == 1);

assert(enumerator[MoveNext]());
assert(enumerator[Current] == 1);

assert(enumerator[MoveNext]());
assert(enumerator[Current] == 2);

assert(!enumerator[MoveNext]());
```



### Parameters
- `this`: The first sequence to concatenate.
- `enumerable`: The second sequence to concatenate.
### Returns
An `IEnumerable` that contains the concatenated  elements of the two input sequences.


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

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/linq
[ns1]: https://www.npmjs.com/package/@kingjs/linq.concat
npm package: @kingjs/linq.contains
Description: Returns true if a sequence contains a specified element.
Author: Chris King
Latest version: 1.0.7

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).contains
Returns true if a sequence contains a specified element.
## Usage
Discover if the sequence `1`, `2`, `3` contains the value `2` like this:
```js
var contains = require('@kingjs/linq.contains');
var sequence = require('@kingjs/enumerable.create');

contains.call(sequence(1, 2, 3), 2);
```
result:
```js
true
```
Discover if `'Chris'` is contained in a list of people like this:
```js
var contains = require('@kingjs/linq.contains');
var sequence = require('@kingjs/enumerable.create');

var people = sequence(
  { name: 'Alice' },
  { name: 'Bob' },
  { name: 'Chris' },
);

var equal = function(l, r) { 
  return l.name == r.name; 
}

contains.call(people, { name: 'Chris' }, equal);
```
result:
```js
true
```
## API

```ts
declare function contains(
  this: Enumerable,
  target: any,
  equal?: (left, right) => boolean
): boolean
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).
 
### Parameters
- `this`: The sequence to search.
- `target`: The value to find.
- `equal`: Optional comparison operator.

### Return Value
Returns `true` if `target` is present, `false` otherwise.

## Remarks
By default, the comparison operator is Javascript's `==` operator.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.contains
```
## Acknowledgments
Like [Enumerable.Contains](https://msdn.microsoft.com/en-us/library/bb339118(v=vs.110).aspx).

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/contains)
npm package: @kingjs/linq.count
Description: Returns the number of elements in a sequence that satisfy a condition.
Author: Chris King
Latest version: 1.0.6

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).count
Returns the number of elements in a sequence that satisfy a condition.
## Usage
Count the number of elements in sequence `1`, `2`, `3` like this:
```js
var count = require('@kingjs/linq.count');
var sequence = require('@kingjs/enumerable.create');

count.call(sequence(1, 2, 3));
```
result:
```js
3
```
Count the number of odd numbers in sequence `1`, `2`, `3` like this:
```js
var count = require('@kingjs/linq.count');
var sequence = require('@kingjs/enumerable.create');

var isOdd = function(o) { return o % 2 == 1; }

count.call(sequence(1, 2, 3), isOdd);
```
result:
```js
2
```
## API
```ts
declare function count(
    this: Enumerable,
    predicate?: (x) => boolean
): number
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: The sequence to count values matching predicate.
- `predicate`: To be counted, values must match this predicate. 

### Return Value
Returns the number of values that satisfy the predicate.

## Remarks
By default, the predicate is satisfied by any value.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.count
```

## Acknowledgments
Like [`Enumerable.Count`](https://msdn.microsoft.com/en-us/library/bb535181(v=vs.110).aspx).

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/count)
npm package: @kingjs/linq.default-equal
Description: Default equality operator.
Author: Chris King
Latest version: 1.0.8

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).default-equal
Default `equal` operator used by LINQ functions.
## API
```ts
function defaultEqual(
  left: any, 
  right: any
): boolean;
```

### Parameters
- `left`: The left operand. 
- `right`: The right operand.

### Result
Returns result of comparing the operands using the Javascript `==` operator.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/link.default-equal
```

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/default-equal)
npm package: @kingjs/linq.default-less-than
Description: Default lessThan operator.
Author: Chris King
Latest version: 1.0.6

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).default-less-than
Default `lessThan` operator used by LINQ functions.
## API

```ts
function defaultLessThan(
  left: any, 
  right: any
): boolean;
```

### Parameters
- `left`: The left operand. 
- `right`: The right operand.

### Result
Returns result of comparing the operands using the Javascript `<` operator.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/link.default-less-than
```

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/default-less-than)
npm package: @kingjs/linq.default-select-id
Description: Default id selector; Identity operator.
Author: Chris King
Latest version: 1.0.4
Deprecated: 'Keys

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).default-selectId
Default id selector; Identity operator.
## Usage
Id selectors are used to identify objects when the default string conversion is insufficient. For example, implement a function remove duplicates from an array like this:
```js
var defaultSelectId = require('@kingjs/linq.default-select-id');

function removeDuplicates(array, selectId) {
  var result = [];

  if (!selectId)
    selectId = defaultSelectId;

  var visited = { };
  for (var i = 0; i < array.length; i ++) {
    var value = array[i];

    var id = selectId(value);
    if (id in visited)
      continue;
    visited[id] = undefined;

    result.push(value);
  }

  return result;
}
```
This can be used to remove the duplicate 'Alice' record when records are:
- strings and default string conversion is sufficient
- objects with a `name` property and an `idSelector` is necessary

For example:
```js
{
  asStrings: removeDuplicates([
    'Alice',
    'Alice',
    'Bob',
  ]),

  asObjects: removeDuplicates([
    { name: 'Alice' },
    { name: 'Alice' },
    { name: 'Bob' },
  ], function(x) { // without this, de-dup fails
    return x.name; 
  }),
}
```
result:
```js
{
  asStrings: [ 
    'Alice', 
    'Bob' 
  ],
  asObjects: [
    { name: 'Alice' },
    { name: 'Bob' }
  ],
}
```

## API
```ts
function defaultIdSelector(x: any): any
```
### Parameters
- `x`: The object whose `id` is to be selected. 

### Result
A value whose string representation identifies the object.

## Remarks
LINQ set algorithms like `union` and `except` need to identify objects and so adopt the `selectId` pattern.

## More Remarks
In C# all objects implement `.GetHashCode` and `.Equals` enabling any object can be used as the key to a dictionary. 

In Javascript only strings may be used as keys. As such, an object used as a key to a dictionary needs to be converted to a string. When the default conversion may not suitable for this purpose, functions should allow callers to pass an `idSelector`. 

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/link.default-equal
```

## License

MIT
npm package: @kingjs/linq.define
Description: Helper to define linq extensions.
Author: Chris King
Latest version: 1.0.1
Deprecated: see @kingjs/reflect.export-extension

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).all
Returns true if all elements of a sequence satisfy a condition.
## Usage
Test if all the numbers 0, 1, and 2, are less than 3 like this:

```js
var all = require('@kingjs/linq.all');
var sequence = require('@kingjs/enumerable.create');

var enumerable = sequence(0, 1, 2);

all.call(enumerable,
  function(o) { return o < 3; }
);
```
result:
```js
true
```
## API
```ts
declare function all(
  this: Enumerable,
  predicate?: (x) => boolean
): boolean
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: A sequence of values. 
- `predicate` The predicate values are tested against.

### Return Value
Returns `true` if `predicate` is `true` for all values, otherwise, `false`.

## Remarks
Calling `all` on an empty sequence returns `true`. 

The default `predicate` returns `true` for every value.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.all
```

## Acknowledgments
Like [Enumerable.All](https://msdn.microsoft.com/en-us/library/bb548541(v=vs.110).aspx)

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/all)
npm package: @kingjs/linq.define-extension
Description: Define an IEnumerable extension with 'linq' prefix.
Author: Chris King
Latest version: 1.0.2
Deprecated: remove i-enumerable

# @kingjs/linq.define-extension

Define an `IEnumerable` extension with "linq" prefix.

## Usage
Intended for internal use. 

Registers `aggregate` function on `IEnumerable` with "linq" prefix and expose as the `module.export` like this:
```js
var defineExtension = requires('@kingjs/linq.define-extension')

defineExtension(module, function aggregate(seed, aggregator) {    
  var enumerator = this.getEnumerator();
  
  var result = seed;
  while (enumerator.moveNext())
    result = aggregator(result, enumerator.current);
  
  return result;
});
```

## API
```ts
define function defineExtension(module: object, extension: Function);
```

### Parameters
> `module` the module object.

> `extension` the extension function to register with `IEnumerable` with "linq" prefix and expose as the `module.export`.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.define-extension
```

## License

MIT
npm package: @kingjs/linq.distinct
Description: Generates a sequence composed of the distinct elements of another sequence.
Author: Chris King
Latest version: 1.0.10

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).distinct
Generates a sequence composed of the distinct elements of another sequence.
## Usage
Remove duplicates from the sequence `0`, `0` like this:
```js
var distinct = require('@kingjs/linq.distinct');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var justZero = distinct.call(sequence(0, 0));

toArray.call(justZero);
```
result:
```js
[0]
```
Remove duplicates from a sequence based on an `id` like this:
```js
var distinct = require('@kingjs/linq.distinct');
var sequence = require('@kingjs/enumerable.create');
var toArray = require('@kingjs/linq.to-array');

var enumerable = sequence(
  { id: 0, name: 'foo' },
  { id: 0, name: 'bar' }
);

var justZero = distinct.call(
  enumerable, 
  function(x) { return x.id; }
);

toArray.call(justZero);
```
result:
```js
[{ 
  id: 0,
  name: 'foo'
}]
```

## API
```ts
function distinct(
  this: Enumerable, 
  selectId?: (x) => any
): Enumerable;
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: The sequence to deduplicate.
- `selectId`: Optional, function to select an identifier.

### Result
Returns a de-duplicated sequence.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/link.distinct
```

## Acknowledgments
Like [`Enumerable.Distinct`](https://msdn.microsoft.com/en-us/library/bb338049(v=vs.110).aspx).

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/distinct)
npm package: @kingjs/linq.element-at
Description: Returns the element at a specified index in a sequence.
Author: Chris King
Latest version: 1.0.9

# @[kingjs](https://www.npmjs.com/package/kingjs)/[linq](https://www.npmjs.com/package/@kingjs/linq).element-at
Returns the element at a specified index in a sequence.
## Usage
Return the 2nd element in the sequence `0`, `1`, `2` like this:
```js
var elementAt = require('@kingjs/linq.element-at');
var sequence = require('@kingjs/enumerable.create');

elementAt.call(sequence(0, 1, 2), 1);
```
result:
```js
1
```

## API
```ts
declare function elementAt(
  this: Enumerable,
  index: number
): any
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).

### Parameters
- `this`: The sequence to traverse.
- `index`: The 0 based index of of the sequence to return.

### Return Value
The 0 based index of of the sequence or an exception if the sequence is too short.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/linq.element-at
```
## See Also
Like [Enumerable.ElementAt](https://msdn.microsoft.com/en-us/library/bb299233(v=vs.110).aspx).

## License

MIT

![Analytics](https://analytics.kingjs.net/linq/element-at)