open-index/open-npm huggingface dataset:
npm package: @kingjan1999/pdfmake
Description: Client/server side PDF printing in pure JavaScript
Author: Bartek Pampuch
Latest version: 0.2.0-alpha.2

# pdfmake [![Build Status][travis_img]][travis_url] [![GitHub][github_img]][github_url] [![npm][npm_img]][npm_url] [![Bower][bower_img]][bower_url] [![Packagist][packagist_img]][packagist_url] [![CDNJS][cdnjs_img]][cndjs_url]

[travis_img]: https://travis-ci.org/bpampuch/pdfmake.svg?branch=master
[travis_url]: https://travis-ci.org/bpampuch/pdfmake

[github_img]: https://img.shields.io/github/release/bpampuch/pdfmake.svg
[github_url]: https://github.com/bpampuch/pdfmake/releases/latest

[npm_img]: https://img.shields.io/npm/v/pdfmake.svg?colorB=0E7FBF
[npm_url]: https://www.npmjs.com/package/pdfmake

[bower_img]: https://img.shields.io/bower/v/pdfmake.svg?colorB=0E7FBF
[bower_url]: https://github.com/bpampuch/pdfmake

[packagist_img]: https://img.shields.io/packagist/v/bpampuch/pdfmake.svg?colorB=0E7FBF
[packagist_url]: https://packagist.org/packages/bpampuch/pdfmake

[cdnjs_img]: https://img.shields.io/cdnjs/v/pdfmake.svg?colorB=0E7FBF
[cndjs_url]: https://cdnjs.com/libraries/pdfmake


PDF document generation library for server-side and client-side in pure JavaScript.

Check out [the playground](http://bpampuch.github.io/pdfmake/playground.html) and [examples](https://github.com/bpampuch/pdfmake/tree/master/examples).

#### This is unstable master branch for version 0.2.x, for stable version 0.1.x see [branch 0.1](https://github.com/bpampuch/pdfmake/tree/0.1).

### Features

* line-wrapping,
* text-alignments (left, right, centered, justified),
* numbered and bulleted lists,
* tables and columns
  * auto/fixed/star-sized widths,
  * col-spans and row-spans,
  * headers automatically repeated in case of a page-break,
* images and vector graphics,
* convenient styling and style inheritance,
* page headers and footers:
  * static or dynamic content,
  * access to current page number and page count,
* background-layer,
* page dimensions and orientations,
* margins,
* custom page breaks,
* font embedding,
* support for complex, multi-level (nested) structures,
* table of contents,
* helper methods for opening/printing/downloading the generated PDF,
* setting of PDF metadata (e.g. author, subject).

## Documentation

Documentation URL: https://pdfmake.github.io/docs/

## Building from sources

using npm:
```
git clone https://github.com/bpampuch/pdfmake.git
cd pdfmake
npm install
npm run build
```

using yarn:
```
git clone https://github.com/bpampuch/pdfmake.git
cd pdfmake
yarn
yarn run build
```

## License
MIT

## Authors
* [@bpampuch](https://github.com/bpampuch) (founder)
* [@liborm85](https://github.com/liborm85)

pdfmake is based on a truly amazing library [pdfkit](https://github.com/devongovett/pdfkit) (credits to [@devongovett](https://github.com/devongovett)).

Thanks to all contributors.
npm package: @kingjan1999/rapipdf-cli
Description: ```sh-session $ npm install -g @kingjan1999/rapipdf-cli $ rapipdf (-v|--version|version) @kingjan1999/rapipdf-cli/0.0.3 linux-x64 node-v14.15.1 $ rapipdf --help [COMMAND] USAGE $ rapipdf SpecFile # can be either the path to a local file or a remote url (b
Author: Jan Beckmann @kingjan1999
Latest version: 0.1.0

Unofficial CLI for RapiPDF
===========

[![Version](https://img.shields.io/npm/v/@kingjan1999/rapipdf-cli.svg)](https://www.npmjs.com/package/@kingjan1999/rapipdf-cli)
[![Downloads/week](https://img.shields.io/npm/dw/@kingjan1999/rapipdf-cli.svg)](https://npmjs.org/package/@kingjan1999/rapipdf-cli)
[![License](https://img.shields.io/npm/l/@kingjan1999/rapipdf-cli.svg)](https://github.com/kingjan1999/rapipdf-cli/blob/master/package.json)

This project is an adaption of [RapiPDF](https://github.com/mrin9/RapiPdf) providing a CLI for generating PDFs based on OpenAPI specs.
Apart from just providing an CLI, some additional configuration options (e.g. adding a logo) are provided.

<!-- toc -->
* [Usage](#usage)
* [Configuration File](#configuration-file)
<!-- tocstop -->

# Usage
```sh-session
$ npm install -g @kingjan1999/rapipdf-cli
$ rapipdf (-v|--version|version)
@kingjan1999/rapipdf-cli/0.0.3 linux-x64 node-v14.15.1
$ rapipdf --help [COMMAND]
USAGE
  $ rapipdf SpecFile # can be either the path to a local file or a remote url (both .yaml and .json are supported)

OPTIONS

  -c, --configFile=configFile # pass the path to the configuration file (optional, see below)
  -o, --outputFile=outputFile # pass the path to the output file (defaults to "api.pdf")
```


# Configuration File

You can pass a configuration file to the CLI (using the `-c` parameter) overriding the defaults. An example is provided in this repository (`rapipdf.config.example-de.json`).

# Example Usage

Calling

```sh-session
$ rapipdf -o petstore.json.pdf -c config.json  petstore.json
```

in the `examples/` folder results in the uploaded [petstore.json.pdf](https://github.com/kingjan1999/rapipdf-cli/raw/master/examples/petstore.json.pdf).
npm package: @kingjs/array
Description: Exports all `@kingjs/array.*` functionality in one package.
Author: Chris King
Latest version: 1.0.5
Deprecated: see kingjs

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

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

  [nested]: https://www.npmjs.com/package/@kingjs/array.nested
  [make-enumerable]: https://www.npmjs.com/package/@kingjs/array.make-enumerable
npm package: @kingjs/array-enumerable
Description: Wraps an array in an enumerable.
Author: Chris King
Latest version: 1.0.4
Deprecated: see @kingjs/array.make-enumerable

# @kingjs/array-enumerable

Wraps an array in an enumerable.

## Usage

To allow someone to enumerate your array without allowing them to change the array, you can wrap it in an enumerable like this:

```js
var ArrayEnumerable = require('@kingjs/array-enumerable')

var myArray = [0, 1, 2];

var yourEnumerable = new ArrayEnumerable(myArray);
var yourEnumerator = yourEnumerable.getEnumerator();

var yourArray = [];
while (yourEnumerator.moveNext()) 
  yourArray.push(yourEnumerator.current);

yourArray;
```

outputs:

```js
[0, 1, 2];
```

## API

```ts
function ArrayEnumerable(array?: any[]): {
  getEnumerator: {
    (): {
      moveNext: { (): Boolean },
      current: any
    }
  }
}
```
### Parameters
> `array`: the array like object to enumerate.

### Return Value
> An enumerable which returns the elements of the array.

## Remarks
"Array like" objects like `arguments` which are not of type `Array` yet have a `length` property and a range of other properties from 0 to `length` -1 may also be enumerated with `ArrayEnumerator`.

`ArrayEnumerable` is registered as an [`IEnumerable`][i-enumerable] implementation.

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

```
$ npm install @kingjs/array-enumerable
```

## Acknowledgments
`ArrayEnumerable` was inspired by LINQ.

## See Also
- [`LINQ`][linq]
- [IEnumerable][i-enumerable]  

## License

MIT

  [i-enumerable]: https://www.npmjs.com/package/@kingjs/i-enumerable
  [linq]: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/concepts/linq/getting-started-with-linq
npm package: @kingjs/array.make-enumerable
Description: Makes an array enumerable by adding a `getEnumerable` method.
Author: Chris King
Latest version: 1.0.5
Deprecated: see kingjs

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

// array is an Array...
array.push(3); 

// ...that can also be enumerated...
var enumerator = array.getEnumerator();

// ...at the cost of becoming frozen.
// sequence.push(4); 

var result = [];
while (enumerator.moveNext())
  result.push(enumerator.current);
result;
```
result:
```js
[ 1, 2, 3 ]
```
## API
```ts
declare function makeEnumerable(
  this: Array
): Enumerable
```
### Interfaces
- `Enumerable`: See [@kingjs/enumerable.define](https://www.npmjs.com/package/@kingjs/enumerable.define).
### Parameters
- `this`: The array to augment with function `getEnumerator`.
### Returns
Returns `this` after adding a `getEnumerable` function. 
## Remarks
The array is frozen by the first call to `getEnumerator`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/array.make-enumerable
```
## License
MIT

![Analytics](https://analytics.kingjs.net/array/make-enumerable)
npm package: @kingjs/array.nested
Description: Exports all `@kingjs/array.nested.*` functionality in one package.
Author: Chris King
Latest version: 1.0.0
Deprecated: se[Be @kingjs/descriptor.nested.array

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

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

  [for-each]: https://www.npmjs.com/package/@kingjs/array.nested.for-each
npm package: @kingjs/array.nested.for-each
Description: Invokes a callback on leafs of a tree whose internal nodes are nested arrays and whose leafs are any non-array value.
Author: Chris King
Latest version: 1.0.6
Deprecated: see @kingjs/descriptor.nested.array.for-each

# @[kingjs](https://www.npmjs.com/package/kingjs)/[array](https://www.npmjs.com/package/@kingjs/array).[nested](https://www.npmjs.com/package/@kingjs/array.nested).for-each
Invokes a callback on leafs of a tree whose internal nodes are nested arrays and whose leafs are any non-array value.
## Usage
Flatten nested arrays like this:
```js
var forEach = require('@kingjs/array.nested.for-each');

var result = [];

forEach([
  'a', [
    'b', [
      'c'
    ], 'd'
  ], 'e'
], function(x) {
  result.push(x);
});

result;
```
result:
```js
[ 'a', 'b', 'c', 'd', 'e' ]
```
## API
```ts
declare function forEach(
  target: any | any[],
  callback: (x) => void
)
```
### Parameters
- `target`: An non-array leaf or an array of nested array nodes interspersed with non-array leafs.
- `callback`: Callback to invoke for each non-array element.
  - `x`: Current non-array leaf. 
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/array.nested.for-each
```
## License
MIT![Analytics](https://analytics.kingjs.net/array.nested.for-each)
npm package: @kingjs/array.nested.to-array
Description: Returns an array containing the non-array leafs of a tree whose internal nodes are nested arrays.
Author: Chris King
Latest version: 1.0.5
Deprecated: see @kingjs/descriptor.nested.array.to-array

# @[kingjs](https://www.npmjs.com/package/kingjs)/[array](https://www.npmjs.com/package/@kingjs/array).[nested](https://www.npmjs.com/package/@kingjs/array.nested).to-array
Returns an array containing the non-array leafs of a tree whose internal nodes are nested arrays.
## Usage
Flatten nested arrays like this:
```js
var toArray = require('@kingjs/array.nested.toArray');

var result = toArray([
  'a', [
    'b', [
      'c'
    ], 'd'
  ], 'e'
]);

result;
```
result:
```js
[ 'a', 'b', 'c', 'd', 'e' ]
```
## API
```ts
declare function toArray(
  target: any | any[]
): any[]
```
### Parameters
- `target`: An non-array leaf or an array of nested array nodes interspersed with non-array leafs.
### Returns
Returns an array containing the non-array leafs of a tree whose internal nodes are nested arrays. 
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/array.nested.to-array
```
## License
MIT

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

  [enumerable]: https://www.npmjs.com/package/@kingjs/enumerable
npm package: @kingjs/assert
Description: Throw an exception if a condition fails.
Author: Chris King
Latest version: 1.0.11
Deprecated: see builtin modules

# @[kingjs](https://www.npmjs.com/package/kingjs)/assert

Throw an exception if a condition fails.

## Usage

Assert a condition in your code or test like this:
```js
var assert = require('@kingjs/assert');

assert(0 == 1);
```
throws:
```js
"An assertion failed."
```

Simply fail all the time like this:
```js
var assert = require('@kingjs/assert');

assert();
```
throws:
```js
"An assertion failed."
```

Provide a more descriptive error message like this:
```js
var assert = require('@kingjs/assert');

var expected = 0;
var actual = 1;

assert(
  actual == expected,
  "Expected '" + expected + "' but actually got '" + actual + "'."
);
```
throws:
```js
"Expected '0' but actually got '1'."
```

## API
```ts
declare function assert(condition?: boolean, message?: string);
```
### Parameters
> `condition`: If false (or omitted), throws an exception.

> `message`: Message to throw if condition fails, else will throw "An assertion failed.".

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

```
$ npm install @kingjs/assert
```

## Acknowledgments
`assert` is old as dirt and just as underappreciated.

## License

MIT

![Analytics](https://analytics.kingjs.net/assert)
npm package: @kingjs/assert-shimmed
Description: Assert that `kingjs` has been required by the application which means that registered symbols like `@kingjs/IEnumerable.getEnumerator` will have been set on builtin objects like `string` and `array`.
Latest version: 1.0.1

# @[kingjs][@kingjs]/[assert-shimmed][ns0]
Assert that `kingjs` has been required by the application which means that registered symbols like `@kingjs/IEnumerable.getEnumerator` will have been set on builtin objects like `string` and `array`.
## Usage
```js
var assert = require('assert');

var assertShimmed = () => require('@kingjs/assert-shimmed');
assert.throws(() => assertShimmed());

var IEnumerable = Symbol.for('@kingjs/IEnumerable.getEnumerator');

assert(IEnumerable in Array.prototype == false)
assert(IEnumerable in String.prototype == false)

require('kingjs');
assertShimmed();

assert(IEnumerable in Array.prototype)
assert(IEnumerable in String.prototype)
```






## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/assert-shimmed
```

## Source
https://repository.kingjs.net/assert-shimmed
## License
MIT

![Analytics](https://analytics.kingjs.net/assert-shimmed)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/assert-shimmed
npm package: @kingjs/assert-theory
Description: Calls a theory with every combination of elements from an array set.
Author: Chris King
Latest version: 1.0.20

# @[kingjs](https://www.npmjs.com/package/kingjs)/assert-theory
Assert that a theory is true for a combination of observations.
## Usage
Assert that addition and multiplication are [commutative](https://en.wikipedia.org/wiki/Commutative_property) operations for a combination of 3 whole numbers and 3 fractions like this:
```js
var testTheory = require('@kingjs/assert-theory');
var assert = require('@kingjs/assert');

var id = 0;

testTheory(function(o, i) {
  assert(id++ == i);

  var naturalFirst = eval(o.natural + o.op + o.fraction);
  var fractionFirst = eval(o.fraction + o.op + o.natural);

  assert(naturalFirst == fractionFirst); 
}, {
  op: [ '+', '*' ],
  natural: [1, 2, 3],
  fraction: [.1, .2, .3],
});

assert(id == 3 * 3 * 2); // = 18
```
## API
```ts
declare function testTheory(
  theory: (
    this, 
    observation, 
    i
  ) => void,
  observations: { [index: string]: any },
  runId?: number
);
```
### Parameters
- `theory`: A function that tests a set of observations.
  - `this`: The `observations`.
  - `observation`: The observation generated from `data`.
  - `id`: The number identifying `observation`. 
- `observations`: A descriptor whose every property contains either an array, primitive, or object from which a sequence of similar descriptors is generated where each property is replaced with an array element, the primitive, or a property value respectively.
- `runId`: If present, runs only the observation with the given `id`.
## Remarks
If an `observation` fails then it can be easily debugged by supplying `runId`. If `runId` is specified an exception is still thrown after the test pass to ensure that the `runId` is removed.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/assert-theory
```
## Acknowledgments
Like nUnit [`TheoryAttribute`](https://github.com/nunit/docs/wiki/Theory-Attribute).
## License
MIT

![Analytics](https://analytics.kingjs.net/assert-theory)
npm package: @kingjs/assert-throws
Description: Throw an exception if a function fails to throw an exception.
Author: Chris King
Latest version: 1.0.6
Deprecated: see builtin node modules

# @[kingjs](https://www.npmjs.com/package/kingjs)/assert-throws

Throw an exception if a function fails to throw an exception.

## Usage

Assert that a function throws an exception like this:
```js
var assertThrows = require('@kingjs/assert-throws');
assertThrows(function() { });
```
throws:
```js
"An assertion failed."
```

Provide a more descriptive error message like this:
```js
var assertThrows = require('@kingjs/assert-throws');

assertThrows(
  function() { }, 
  "Expected an exception, but actually passed."
) 
```
throws:
```js
"Expected an exception, but actually passed."
```

## API
```ts
declare function assertThrows(func: Function, message?: string);
```
### Parameters
> `func`: Function expected to throw an exception.

> `message`: Message to throw if `func` fails to throw an exception, else will throw "An assertion failed.".

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/assert-throws
```

## License

MIT

![Analytics](https://analytics.kingjs.net/assert-throws)
npm package: @kingjs/built-in-symbols
Description: Returns an object whose properties are the set of built in symbols. ## Remarks Basically, a reverse mapping of the properties on Symbol filtered by those properties whose values are actually symbols.  ## Install With [npm](https://npmjs.org/) installed, r
Latest version: 1.0.0
Deprecated: see @kingjs/reflect.built-in-symbols

# @[kingjs](https://www.npmjs.com/package/kingjs)/built-in-symbols
Returns an object whose properties are the set of built in symbols.
## Remarks
Basically, a reverse mapping of the properties on Symbol filtered by those properties whose values are actually symbols. 
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/built-in-symbols
```
## License
MIT

![Analytics](https://analytics.kingjs.net/built-in-symbols)
npm package: @kingjs/camel-case.join
Description: ## Usage ```js var assert = require('assert'); var join = require('@kingjs/camel-case.join');
Latest version: 1.0.0

# @[kingjs][@kingjs]/[camel-case][ns0].[join][ns1]

## Usage
```js
var assert = require('assert');
var join = require('@kingjs/camel-case.join');

var together = join(['foo', 'bar']);
assert(together == 'fooBar');

var together = join(['foo', 'bar'], true);
assert(together == 'FooBar');

var together = join([]);
assert(together === null);

var together = join(['']);
assert(together === null);
```
## API
```ts
join(names[, capitalize])
```
### Parameters
- `names`: Array of names to join together into a camel case string.
- `capitalize`: True if the result should be capitalized.
### Returns
Returns a camel case string, optionally capitalized, or null.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/camel-case.join
```
## License
MIT

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/camel-case
[ns1]: https://www.npmjs.com/package/@kingjs/camel-case.join
npm package: @kingjs/camel-case.split
Description: ## Usage ```js var assert = require('assert'); var split = require('@kingjs/camel-case.split');
Latest version: 1.0.0

# @[kingjs][@kingjs]/[camel-case][ns0].[split][ns1]

## Usage
```js
var assert = require('assert');
var split = require('@kingjs/camel-case.split');

var apart = split('fooBar');
assert(apart.length == 2);
assert(apart[0] = 'foo');
assert(apart[1] = 'bar');

var apart = split('FooBar');
assert(apart.length == 2);
assert(apart[0] = 'foo');
assert(apart[1] = 'bar');

var apart = split('FBar');
assert(apart.length == 2);
assert(apart[0] = 'f');
assert(apart[1] = 'bar');

var apart = split('');
assert(apart.length == 0);

```
## API
```ts
split(name)
```
### Parameters
- `name`: A camel case name to split.
### Returns
Array of names, all lower case, composing the camel case name.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/camel-case.split
```
## License
MIT

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/camel-case
[ns1]: https://www.npmjs.com/package/@kingjs/camel-case.split
npm package: @kingjs/case-at
Description: Functions for testing and setting the case of a character in a string.
Author: Chris King
Latest version: 1.0.5
Deprecated: see @kingjs/string-ex namespace

# @[kingjs](https://www.npmjs.com/package/kingjs)/case-at

Functions for testing and setting the case of a character in a string.

## Usage

Test the if "H" in "Hello World!" is upper case like this:
```js
var caseAt = require('@kingjs/case-at');
caseAt.isRaised("Hello World!", 0);
```
returns
```js
true
```

Lower the the case of "W" in "Hello world!" like this:
```js
var caseAt = require('@kingjs/case-at');
caseAt.lower("Hello World!", 6);
```
returns
```js
"Hello world!"
```

## API
```ts
declare function isRaised(value: string, index: number): boolean;
declare function isLowered(value: string, index: number): boolean;
declare function raise(value: string, index: number): string;
declare function lower(value: string, index: number): string;
```
### Parameters
> `isRaised`: True if the character at `string`'s `index` is upper case.

> `isLower`: True if the character at `string`'s `index` is lower case.

> `raise`: Raise the case of the character at `string`'s `index`.

> `lower`: Lower the case of the character at `string`'s `index`.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/case-at
```

## License

MIT

![Analytics](https://analytics.kingjs.net/case-at)
npm package: @kingjs/copy
Description: Copies own and inherited enumerable property values optionally skipping those already defined.
Author: Chris King
Latest version: 1.0.3
Deprecated: see @kingjs/mutate.copy

# @[kingjs](https://www.npmjs.com/package/kingjs)/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(target, source); 
```
result:
```js
{
  a: 0,
  b: 2,
  c: 3
}
```
## API
```ts
declare function copy(
  target, 
  source?, 
  skipIfDefined?: boolean | (name) => boolean,
): any
```
### Parameters
- `target`: An object to which properties are copied.
- `source`: An object whose properties are copied to target.
- `skipIfDefined`: Prevent overwriting:
  - If `true`.
  - If a function that returns `true` given:
    - `name`: The name of the existing property.
### Returns
Returns the `target` with properties copied from `source`.
## Remarks
Inherited and own properties are copied. 

Non-enumerable properties are _not_ copied.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/copy
```
## License
MIT
npm package: @kingjs/create-constructor
Description: Create a constructor from a base function and a body function.
Author: Chris King
Latest version: 1.0.1

# @[kingjs](https://www.npmjs.com/package/kingjs)/create-constructor
## Usage
```js
var createConstructor = require('@kingjs/create-constructor');

var Vehicle = createConstructor(
  'Vehicle',
  null,
  function Vehicle(company, name) { 
    this.company = company;
    this.name = name;
  }
);
Vehicle.prototype.isVehicle = true;

var Car = createConstructor(
  'Car',
  Vehicle
);
Car.prototype.isCar = true;

var Truck = createConstructor(
  'Truck',
  Vehicle,
  function(company, name, towingCapacity) {
    this.towingCapacity = towingCapacity;
  }
);
Truck.prototype.isTruck = true;
```
result:
```js
```
## API
```ts
declare function createConstructor(
): any
```
### Parameters
### Returns
## Remarks
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/create-constructor
```
## License
MIT

![Analytics](https://analytics.kingjs.net/create-constructor)
npm package: @kingjs/create-depjs
Description: Generates dependencies.js which exports the dependencies in package.json.
Latest version: 1.0.0

# @[kingjs][@kingjs]/[create-depjs][ns0]
Generates dependencies.js which exports the dependencies in package.json.
## Usage
Given a `package.json` like this:
```js
{
  "name": "@kingjs/tools.create-dependencies-js",
  "version": "1.0.0",
  "dependencies": {
    "@kingjs/camel-case.join": "^1.0.0",
    "@kingjs/package-name.parse": "^1.0.1"
  }
}

```
Running this:
```
$ cdj 
```
Produces a `dependencies.js` like this:
```js
exports['@kingjs'] = {
  camelCase: {
    join: require('@kingjs/camel-case.join'),
  },
  packageName: {
    parse: require('@kingjs/package-name.parse'),
  },
}
``` 
Which can then be used in like this:
```js
var assert = require('assert');

var { 
  ['@kingjs']: {
    packageName: { parse },
    camelCase: { join }
  }
} = require('./dependencies');

assert(parse);
assert(join);
``` 
## Remarks
Using `dependencies.js` ensures that production code requires only packages listed in as dependencies in `package.json`.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install -g @kingjs/create-depjs
```
## License
MIT

![Analytics](https://analytics.kingjs.net/create-depjs)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/create-depjs
npm package: @kingjs/create-enumerable-type
Description: Create an enumerable type from a `MoveNext()` factory.
Author: Chris King
Latest version: 1.0.3
Deprecated: 'see

# @kingjs/create-enumerable-type

Create an enumerable type from a `MoveNext()` factory.

## Usage

Create an enumerable type for iterating `Array` using a `moveNext()` factory like this:

```js
var createEnumerableType = require('@kingjs/create-enumerable-type');

var moveNextFactory = function(array) {
  var index = -1;
  return function moveNext() {
    if (index + 1 == array.length)
      return false;
    this.current_ = array[++index];
    return true;
  }
}

var ArrayEnumerable = createEnumerableType(moveNextFactory);
```
Voila! Now, test the `ArrayEnumerable` like this:
```js
var enumerable = new ArrayEnumerable([0, 1, 2]);
var enumerator = enumerable.getEnumerator();

var actual = [];
while (enumerator.moveNext())
  actual.push(enumerator.current);
actual;
```

outputs:

```js
[0, 1, 2];
```

## API

```ts
declare function createEnumerableType(
    moveNextFactory: {
        (...args: any[]): {
            moveNext: { (): Boolean }
        }
    }): typeof Enumerable;
    
declare class Enumerable {
    constructor(...args: any[]);

    getEnumerator: {
        (): {
            moveNext: { (): Boolean },
            current: any
        }
    }
}
```
### Parameters
> `moveNextFactory`: a function that returns a `moveNext()` function closed over the enumerable activation arguments.

### Return Value
> An enumerable type whose activation arguments are saved and passed to the specified `moveNextFactory` when `getEnumerator()` is called.

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

```
$ npm install @kingjs/create-enumerable
```

## Acknowledgments
`create-enumerable` was inspired by the boilerplate generated by C# `yield` syntax. Though we cannot generate the state machine, we can generate the type scaffolding.

## See Also
- [C# yield](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/yield)

## License

MIT
npm package: @kingjs/create-interface
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.1
Deprecated: see @kingjs/define-interface

# @[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/create-links
Description: Recursively creates npm links for all  dependent packages.
Latest version: 1.0.0

# @[kingjs][@kingjs]/[create-links][ns0]
Recursively creates npm links for all  dependent packages.
## Usage
```js
var assert = require('assert');
var xxx = require('@kingjs/create-links');
```

## API
```ts
createLinks()
```




## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/create-links
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/git.get-dir`](https://www.npmjs.com/package/@kingjs/git.get-dir)|`^1.0.0`|
|[`@kingjs/package-name.parse`](https://www.npmjs.com/package/@kingjs/package-name.parse)|`^1.0.1`|
|[`shelljs`](https://www.npmjs.com/package/shelljs)|`^0.8.3`|
## Source
https://repository.kingjs.net/create-links
## License
MIT

![Analytics](https://analytics.kingjs.net/create-links)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/create-links
npm package: @kingjs/create-package
Description: Creates or updates fields of `package.json` that can be inferred from the surrounding environment.
Latest version: 1.0.1

# @[kingjs][@kingjs]/[create-package][ns0]
Creates or updates fields of `package.json` that can be inferred from the surrounding environment.
## Usage
Given a `package.json` at a relative path `create-package/example` like this:
```js
{
  "name": "",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "files": [
    "*.js"
  ],
  "repository": {
    "type": "git",
    "url": ""
  },
  "license": "MIT",
  "dependencies": {
  }
}

```
And a `index.js` like this:
```js
/**
 * @description A description of the package.
 */
function example() { }
```
Running this:
```
$ cpk
```
Produces a `package.json` like this:
```js
{
  "name": "@kingjs/create-package.example",
  "version": "1.0.0",
  "description": "A description of the package.",
  "main": "index.js",
  "files": [
    "*.js"
  ],
  "repository": {
    "type": "git",
    "url": "https://repository.kingjs.net/create-package/example"
  },
  "license": "MIT",
  "dependencies": {}
}
``` 
## API
```ts
createPackage()
```

### Remarks
The following are harvested from environment:
- `description`: The first JsDoc `description` found in the `main` js file.
- `name`: A join with period of the relative path of this package in the repository.
- `repository.url`: `https://repository.kingjs.net/` plus a join with forward slash of the relative paths in the repository.
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm init @kingjs/package
```
or
```
$ npm install -g @kingjs/create-package
$ cpk
```
## Execute
With [npx](https://www.npmjs.com/package/npx) installed, run
```
$ npx @kingjs/create-package
```
## License
MIT

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

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/create-package
npm package: @kingjs/create-readme
Description: The master readme template for the `kingjs` scope.
Latest version: 1.0.7

# @[kingjs][@kingjs]/[create-readme][ns0]
The master readme template for the `kingjs` scope.
## Usage
Given a `package.json` like this:
```
{
  "name": "@kingjs/readme-template.test",
  "version": "1.0.0",
  "description": "Test of the master readme template for the `kingjs` scope.",
  "main": "index.js",
  "files": [
    "*.js"
  ],
  "repository": {
    "type": "git",
    "url": "https://repository.kingjs.net/readme-template"
  },
  "license": "MIT",
  "dependencies": {
    "@kingjs/is": "^1.0.9"
  }
}

```
And given a `index.js` like this:
```js
/**
 * @this any This comment
 * 
 * @param callback Callback comment.
 * @param foo Foo comment.
 * @param [bar] Bar comment.
 * @param [baz] Baz comment.
 * 
 * @returns The return comment.
 * Return comment that spans a line.
 * 
 * @remarks Remarks comment
 * that spans lines.
 * @remarks - Remarks comment on new line.
 * 
 * @callback
 * @param pop Default callback.
 * 
 * @callback foo
 * @param moo Moo comment.
 * @param [boo] Boo comment
 */
function example(callback, foo, bar, baz) { }

```
And given a `.test/readme.js` like this:
```js
var assert = require('assert');
var myPackage = require('..');

// example goes here!
```
Then running `$ erm` will produce a `README.md` like this:
````
# @[kingjs][@kingjs]/[readme-template][ns0].[test][ns1]
Test of the master readme template for the `kingjs` scope.

## API
```ts
example(this, callback(pop), foo(moo[, boo])[, bar[, baz]])
```

### Parameters
- `this`: This comment
- `callback`: Callback comment.
  - `pop`: Default callback.
- `foo`: Foo comment.
  - `moo`: Moo comment.
  - `boo`: Boo comment
- `bar`: Bar comment.
- `baz`: Baz comment.
### Returns
The return comment. Return comment that spans a line.
### Remarks
Remarks comment that spans lines.
- Remarks comment on new line.

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/readme-template.test
```
## Dependencies
|Package|Version|
|---|---|
|[`@kingjs/is`](https://www.npmjs.com/package/@kingjs/is)|`^1.0.9`|
## Source
https://repository.kingjs.net/readme-template
## License
MIT

![Analytics](https://analytics.kingjs.net/readme-template/test)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/readme-template
[ns1]: https://www.npmjs.com/package/@kingjs/readme-template.test

````
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm init @kingjs/readme
```
or
```
$ npm install -g @kingjs/create-readme
$ crm
```
## Execute
With [npx](https://www.npmjs.com/package/npx) installed, run
```
$ npx @kingjs/create-readme
```
## License
MIT

![Analytics](https://analytics.kingjs.net/create-readme)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/create-readme
npm package: @kingjs/define-enumerable-type
Description: Define an enumerable type from a `MoveNext()` factory.
Author: Chris King
Latest version: 1.0.0

# @kingjs/define-enumerable-type

Define an enumerable type from a `MoveNext()` factory.

## Usage

Define an enumerable type for iterating `Array` using a `moveNext()` factory like this:

```js
var defineEnumerableType = require('@kingjs/define-enumerable-type');

var moveNextFactory = function(array) {
  var index = -1;
  return function moveNext() {
    if (index + 1 == array.length)
      return false;
    this.current_ = array[++index];
    return true;
  }
}

var ArrayEnumerable = defineEnumerableType(moveNextFactory);
```
Voila! Now, test the `ArrayEnumerable` like this:
```js
var enumerable = new ArrayEnumerable([0, 1, 2]);
var enumerator = enumerable.getEnumerator();

var actual = [];
while (enumerator.moveNext())
  actual.push(enumerator.current);
actual;
```

outputs:

```js
[0, 1, 2];
```

## API

```ts
declare function defineEnumerableType(
    moveNextFactory: {
        (...args: any[]): {
            moveNext: { (): Boolean }
        }
    }): typeof Enumerable;
    
declare class Enumerable {
    constructor(...args: any[]);

    getEnumerator: {
        (): {
            moveNext: { (): Boolean },
            current: any
        }
    }
}
```
### Parameters
> `moveNextFactory`: a function that returns a `moveNext()` function closed over the enumerable activation arguments.

### Return Value
> An enumerable type whose activation arguments are saved and passed to the specified `moveNextFactory` when `getEnumerator()` is called.

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/define-enumerable-type
```

## Acknowledgments
`define-enumerable-type` was inspired by the boilerplate generated by C# `yield` syntax. Though we cannot generate the state machine, we can generate the type scaffolding.

## See Also
- [C# yield](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/yield)

## License

MIT
npm package: @kingjs/define-extension
Description: Defines a property on a target with a symbol name  derived from `package` and `version`.
Author: Chris King
Latest version: 1.0.1

# @[kingjs][@kingjs]/[define-extension][ns0]
Defines a property on a target with a symbol name  derived from `package` and `version`.

## API
```ts
defineExtension(target, package, version, descriptor)
```

### Parameters
- `target`: The target on which to declare the property.
- `package`: The name of the package containing the extension.
- `version`: The version of the package containing the extension.
- `descriptor`: The descriptor describing the property.
### Returns
The symbol name of the property.
### Remarks
If `descriptor` is a function, then it will be wrapped in an  object with name `value`.

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

## Source
https://repository.kingjs.net/define-extension
## License
MIT

![Analytics](https://analytics.kingjs.net/define-extension)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/define-extension
npm package: @kingjs/define-generator
Description: Define a generator given a 'MoveNext()' factory; Poor man's 'yield'.
Author: Chris King
Latest version: 1.0.4
Deprecated: see @kingjs/enumerable.define

# @kingjs/define-generator

Define a generator given a `MoveNext()` factory; Poor man's `yield`.

## Usage

Yield each argument passed to a function like this:

```js
var defineGenerator = require('@kingjs/define-generator');

var sequence = defineGenerator(
  function moveNextFactory() {
    var array = arguments;
    var index = -1;
    return function moveNext() {
      if (index + 1 == array.length)
        return false;
      this.current_ = array[++index];
      return true;
    }
  }
);
```
Voila! Now, test `sequence` like this:
```js
var enumerator = sequence(0, 1, 2);

var enumerator = enumerable.getEnumerator();

var actual = [];
while (enumerator.moveNext())
  actual.push(enumerator.current);
actual;
```

outputs:

```js
[0, 1, 2];
```

## API

```ts
declare function defineGenerator(
  moveNextFactory: (...args: any[]) => {
    moveNext: () => boolean
  }
): {
  getEnumerator: () => {
    moveNext: () => boolean,
    current: any
  }
}
```
### Parameters
> `moveNextFactory`: A function that returns a `moveNext()` function closed over the arguments passed to the generator.

### Return Value
> An enumerable that uses a `moveNext()` created by calling the `moveNextFactory()` with the arguments passed to the generator.

## Remarks
With first class compiler `yield` support the above example could simply be:
```js
function sequence() {
  for (var i = 0; i < arguments; i++)
    yield arguments[i];
}
```
While `defineGenerator` does not generate the state machine to track which element is next in line, hence the requirement to provide the `moveNextFactory()`, it does generate the type scaffolding, the `Enumerable` and `Enumerator`, which, given the state machine, returns a similar result. 

Only "similar" because the official JavaScript `yield` returns an `Iterator` interface while `defineGenerator` returns an `Enumerable` interface ala C#. 

One critique of the `Iterator` interface is that it creates a new object to wrap the result for every iteration and for termination. For example, an empty sequence requires creation of a `{ done: true }` object when using `Iterator` whereas `Enumerable` simply returns `false` from `moveNext()`. 

## Install
With [npm](https://npmjs.org/) installed, run

```
$ npm install @kingjs/define-generator
```

## Acknowledgments
`define-generator` was inspired by the boilerplate generated by C# `yield` syntax. 

## See Also
- [C# yield](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/yield)

## License

MIT

![Analytics](https://analytics.kingjs.net/enumerable/define)
npm package: @kingjs/define-interface
Description: Defines or aliases a group of global symbols.
Latest version: 1.0.14
Deprecated: see @kingjs/reflect.define-interface

# @[kingjs][@kingjs]/[define-interface][ns0]
Defines or aliases a group of global symbols.
## Usage
```js
'use strict';

var assert = require('assert');
var defineInterface = require('@kingjs/define-interface');

var {
  IInterface,
  IInterface: { Id }
} = defineInterface;

function readMe() {
  var target = { };

  var { IFoo } = defineInterface(target, 'IFoo', {
    id: Symbol.for('@kingjs/IFoo'),
    members: { 
      Foo: Symbol.for('IFoo (custom)'),
      Baz: null,
      iterator: Symbol.iterator
    }
  });

  var { IBar } = defineInterface(target, 'IBar', {
    id: Symbol.for('IBar'),
    members: { Bar: null },
    extends: [ IFoo ]
  });

  var { IBaz } = defineInterface(target, 'IBaz', {
    id: Symbol.for('IBaz')
  });

  assert(IFoo[Id] in IBar);

  assert(target.IFoo == IFoo);
  assert(target.IBar == IBar);
  
  assert.throws(IFoo);
  assert.throws(IBar);

  assert(IFoo.prototype === null);
  assert(IBar.prototype === null);

  assert(Symbol.keyFor(IFoo.Baz) == '@kingjs/IFoo.Baz');
  assert(Symbol.keyFor(IFoo.Foo) == 'IFoo (custom)');
  assert(Symbol.keyFor(IBar.Bar) == 'IBar.Bar');

  assert(Symbol.keyFor(IFoo[Id]) == '@kingjs/IFoo');
  assert(Symbol.keyFor(IBar[Id]) == 'IBar');

  assert(IFoo.name == 'IFoo');
  assert(IBar.name == 'IBar');

  assert(IInterface[Id] in IFoo);
  assert(IInterface[Id] in IBar);

  function FooBar() { }

  FooBar.prototype[IFoo[Id]] = IFoo;
  FooBar.prototype[IFoo.Foo] = 'Foo';
  FooBar.prototype[IFoo.Baz] = 'Baz';

  FooBar.prototype[IBar[Id]] = IBar;
  FooBar.prototype[IBar.Bar] = 'Bar';

  var fooBar = new FooBar();
  assert(IFoo[Id] in fooBar);
  assert(fooBar instanceof IFoo);
  assert(IBar[Id] in fooBar);
  assert(fooBar instanceof IBar);
  assert(fooBar instanceof IBaz == false);
}
readMe();
```



### Remarks

## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/define-interface
```
## Source
https://repository.kingjs.net/define-interface
## License
MIT

![Analytics](https://analytics.kingjs.net/define-interface)

[@kingjs]: https://www.npmjs.com/package/kingjs
[ns0]: https://www.npmjs.com/package/@kingjs/define-interface
npm package: @kingjs/define-symbols
Description: ```js var assert = require('assert'); var defineSymbols = require('@kingjs/define-symbols'); ``` ## API ```ts declare function defineSymbols( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) installed, run ``` $ n
Latest version: 1.0.4

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

![Analytics](https://analytics.kingjs.net/define-symbols)
npm package: @kingjs/define.normalize-accessor
Description: ```js var normalizeAccessor = require('..'); var assert = require('assert')
Latest version: 1.0.0

# @[kingjs](https://www.npmjs.com/package/kingjs)/define.normalize-accessor
## Usage
```js
var normalizeAccessor = require('..');
var assert = require('assert')

var target = { };
var get = function foo() { }
var set = function foo() { }
var bar = 'bar';

var {target, name, descriptor} = normalizeAccessor(target, get, set);
assert(target == target);
assert(name == get.name);
assert(descriptor.get == get);
assert(descriptor.set == set);

var {target, name, descriptor} = normalizeAccessor(target, { get, set });
assert(target == target);
assert(name == get.name);
assert(descriptor.get == get);
assert(descriptor.set == set);

var {target, name, descriptor} = normalizeAccessor(target, bar, get, set);
assert(target == target);
assert(name = bar);
assert(descriptor.get == get);
assert(descriptor.set == set);

var {target, name, descriptor} = normalizeAccessor(target, bar, { get, set });
assert(target == target);
assert(name = bar);
assert(descriptor.get == get);
assert(descriptor.set == set);
```
## API
```ts
declare function normalizeAccessor(
): any
```
### Parameters
### Returns
## Remarks
## Install
With [npm](https://npmjs.org/) installed, run
```
$ npm install @kingjs/define.normalize-accessor
```
## License
MIT

![Analytics](https://analytics.kingjs.net/define.normalize-accessor)
npm package: @kingjs/define.normalize-field
Description: ```js var assert = require('assert'); var normalizeField = require('@kingjs/define.normalize-field'); ``` ## API ```ts declare function normalizeField( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) installed, r
Latest version: 1.0.0

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

![Analytics](https://analytics.kingjs.net/define.normalize-field)
npm package: @kingjs/define.normalize-function
Description: ```js var assert = require('assert'); var normalizeFunction = require('@kingjs/define.normalize-function'); ``` ## API ```ts declare function normalizeFunction( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) ins
Latest version: 1.0.0
Deprecated: 'see

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

![Analytics](https://analytics.kingjs.net/define.normalize-function)
npm package: @kingjs/define.normalize-property
Description: ```js var assert = require('assert'); var normalizeProperty = require('@kingjs/define.normalize-property'); ``` ## API ```ts declare function normalizeProperty( ): any ``` ### Parameters ### Returns ## Remarks ## Install With [npm](https://npmjs.org/) ins
Latest version: 1.0.0
Deprecated: 'none'

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

![Analytics](https://analytics.kingjs.net/define.normalize-property)