#### Returns

A string containing the type expression.

### `describe(parsedType, options)`

Convert a parsed type to a description of the type expression. This method is
especially useful if your users are not familiar with the syntax for type
expressions.

The `describe()` method returns the description in two formats:

+ **Simple format**. A string that provides a complete description of the type
expression.
+ **Extended format**. An object that separates out some of the details about
the outermost type expression, such as whether the type is optional, nullable,
or repeatable.

For example, when you call `describe('?function(new:MyObject, string)=')`, the
method returns the following data:

```js
{
simple: 'optional nullable function(constructs MyObject, string)',
extended: {
description: 'function(string)',
modifiers: {
functionNew: 'Returns MyObject when called with new.',
functionThis: '',
optional: 'Optional.',
nullable: 'May be null.',
repeatable: ''
},
returns: ''
}
}
```

#### Parameters

### Returns

An object with the following properties:

+ `simple`: A string that provides a complete description of the type
expression.
+ `extended`: An object containing details about the outermost type expression.
+ `extended.description`: A string that provides a basic description of the
type expression, excluding the information contained in other properties.
+ `extended.modifiers`: Information about modifiers that apply to the type
expression.
+ `extended.modifiers.functionNew`: A string that describes what a
function returns when called with `new`. Returned only for function
types.
+ `extended.modifiers.functionThis`: A string that describes what the
keyword `this` refers to within a function. Returned only for function
types.
+ `extended.modifiers.nullable`: A string that indicates whether the
type is nullable or non-nullable.
+ `extended.modifiers.optional`: A string that indicates whether the
type is optional.
+ `extended.modifiers.repeatable`: A string that indicates whether the
type can be repeated.
+ `extended.returns`: A string that describes the function's return value.
Returned only for function types.

## Changelog

+ 0.9.0 (June 2020):
+ For the `describe()` and `stringify()` methods, the `options.links`
parameter now accepts either a map or an object.
+ Catharsis now requires Node.js 10 or later.
+ 0.8.11 (July 2019): Updated dependencies.
+ 0.8.10 (May 2019): Updated dependencies.
+ 0.8.9 (July 2017): Type expressions that include an `@` sign (for example,
`module:@prefix/mymodule~myCallback`) are now supported.
+ 0.8.8 (April 2016): Corrected the description of type applications other than
arrays that contain a single type (for example, `Promise.`).
+ 0.8.7 (June 2015):
+ Record types that use numeric literals as property names (for example,
`{0: string}`) are now parsed correctly.
+ Record types with a property that contains a function, with no space after
the preceding colon (for example, `{foo:function()}`), are now parsed
correctly.
+ Repeatable function parameters are no longer required to be enclosed in
brackets, regardless of whether JSDoc-style type expressions are enabled. In
addition, the brackets are omitted when stringifying a parsed type
expression.
+ 0.8.6 (December 2014): Improved the description of the unknown type.
+ 0.8.5 (December 2014): Added support for postfix nullable/non-nullable
operators combined with the optional operator (for example, `foo?=`).
+ 0.8.4 (December 2014): JSDoc-style nested arrays (for example, `number[][]`)
are now parsed correctly when JSDoc-style type expressions are enabled.
+ 0.8.3 (October 2014):
+ Type applications are no longer required to include a period (`.`) as a
separator, regardless of whether JSDoc-style type expressions are enabled.
+ Type unions that are not enclosed in parentheses can now include the
repeatable (`...`) modifier when JSDoc-style type expressions are enabled.
+ Name expressions may now be enclosed in single or double quotation marks
when JSDoc-style type expressions are enabled.
+ 0.8.2 (June 2014): Fixed a compatibility issue with the JSDoc fork of Mozilla
Rhino.
+ 0.8.1 (June 2014): Added support for type unions that are not enclosed in
parentheses, and that contain nullable or non-nullable modifiers (for example,
`!string|!number`).
+ 0.8.0 (May 2014):
+ Added a `describe()` method, which converts a parsed type to a description
of the type.
+ Added a `linkClass` option to the `stringify()` method, and deprecated the
existing `cssClass` option. The `cssClass` option will be removed in a
future release.
+ Clarified and corrected several sections in the `README`.
+ 0.7.1 (April 2014): In record types, property names that begin with a keyword
(for example, `undefinedHTML`) are now parsed correctly when JSDoc-style type
expressions are enabled.
+ 0.7.0 (October 2013):
+ Repeatable type expressions other than name expressions (for example,
`...function()`) are now parsed and stringified correctly.
+ Type expressions that are both repeatable and either nullable or
non-nullable (for example, `...!number`) are now parsed and stringified
correctly.
+ Name expressions are now parsed correctly when they match a property name
in an object instance (for example, `constructor`).
+ 0.6.0 (September 2013): Added support for the type expression `function[]`
when JSDoc-style type expressions are enabled.
+ 0.5.6 (April 2013):
+ For consistency with Closure Compiler, parentheses are no longer required
around type unions, regardless of whether JSDoc-style type expressions are
enabled.
+ For consistency with Closure Compiler, you can now use postfix notation
for the `?` (nullable) and `!` (non-nullable) modifiers. For example,
`?string` and `string?` are now treated as equivalent.
+ String literals and numeric literals are now allowed as property names
within name expressions. For example, the name expression `Foo."bar"` is now
parsed correctly.
+ 0.5.5 (April 2013): Corrected a parsing issue with name expressions that end
with a value enclosed in parentheses.
+ 0.5.4 (April 2013):
+ Repeatable literals (for example, `...*`) are now parsed correctly.
+ When JSDoc-style type expressions are enabled, a name expression can now
contain a value enclosed in parentheses at the end of the name expression
(for example, `MyClass(2)`).
+ 0.5.3 (March 2013): The `parse()` method now correctly parses name expressions
that contain hyphens.
+ 0.5.2 (March 2013): The `parse()` method now correctly parses function types
when JSDoc-style type expressions are enabled.
+ 0.5.1 (March 2013): Newlines and extra spaces are now removed from type
expressions before they are parsed.
+ 0.5.0 (March 2013):
+ The `parse()` method's `lenient` option has been renamed to `jsdoc`.
**Note**: This change is not backwards-compatible with previous versions.
+ The `stringify()` method now accepts `cssClass` and `links` options, which
you can use to add HTML links to a type expression.
+ 0.4.3 (March 2013):
+ The `stringify()` method no longer caches HTML-safe type expressions as if
they were normal type expressions.
+ The `stringify()` method's options parameter may now include an
`options.restringify` property, and the behavior of the `options.useCache`
property has changed.
+ 0.4.2 (March 2013):
+ When lenient parsing is enabled, name expressions can now contain the
characters `:` and `/`.
+ When lenient parsing is enabled, a name expression followed by `[]` (for
example, `string[]`) will be interpreted as a type application with the
expression `Array` (for example, `Array.`).
+ 0.4.1 (March 2013):
+ The `parse()` and `stringify()` methods now honor all of the specified
options.
+ When lenient parsing is enabled, name expressions can now contain a
reserved word.
+ 0.4.0 (March 2013):
+ Catharsis now supports a lenient parsing option that can parse several
kinds of malformed type expressions. See the documentation for details.
+ The objects containing parse results are now frozen.
+ The objects containing parse results now have two non-enumerable
properties:
+ `lenient`: A boolean indicating whether the type expression was parsed
in lenient mode.
+ `typeExpression`: A string containing the original type expression.
+ The `stringify()` method now honors the `useCache` option. If a parsed
type includes a `typeExpression` property, and `useCache` is not set to
`false`, the stringified type will be identical to the original type
expression.
+ 0.3.1 (March 2013): Type expressions that begin with a reserved word, such as
`integer`, are now parsed correctly.
+ 0.3.0 (March 2013):
+ The `parse()` and `stringify()` methods are now synchronous, and the
`parseSync()` and `stringifySync()` methods have been removed. **Note**:
This change is not backwards-compatible with previous versions.
+ The parse results now use a significantly different format from previous
versions. The new format is more expressive and is similar, but not
identical, to the format used by the
[doctrine](https://github.com/eslint/doctrine) parser. **Note**: This change
is not backwards-compatible with previous versions.
+ Name expressions that contain a reserved word now include a
`reservedWord: true` property.
+ Union types that are optional or nullable, or that can be repeated, are
now parsed and stringified correctly.
+ Optional function types and record types are now parsed and stringified
correctly.
+ Function types now longer include `new` or `this` properties unless the
properties are defined in the type expression. In addition, the `new` and
`this` properties can now use any type expression.
+ In record types, the key for a field type can now use any type expression.
+ Standalone single-character literals, such as ALL (`*`), are now parsed
and stringified correctly.
+ `null` and `undefined` literals with additional properties, such as
`repeatable`, are now stringified correctly.
+ 0.2.0 (November 2012):
+ Added `stringify()` and `stringifySync()` methods, which convert a parsed
type to a type expression.
+ Simplified the parse results for function signatures. **Note**: This
change is not backwards-compatible with previous versions.
+ Corrected minor errors in README.md.
+ 0.1.1 (November 2012): Added `opts` argument to `parse()` and `parseSync()`
methods. **Note**: The change to `parse()` is not backwards-compatible with
previous versions.
+ 0.1.0 (November 2012): Initial release.

## License