@workday/canvas-kit-docs 9.0.0-alpha.368-next.6 → 9.0.0-alpha.382-next.2

package/dist/es6/docgen/docParser.js

@@ -1,20 +1,8 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 import ts from 'typescript';
 import { getExternalSymbol } from './getExternalSymbol';
 import t, { find } from './traverse';
-var DocParser = /** @class */ (function () {
-    function DocParser(program, plugins) {
-        if (plugins === void 0) { plugins = []; }
+export class DocParser {
+    constructor(program, plugins = []) {
         this.program = program;
         this.plugins = plugins;
         /**
@@ -28,14 +16,13 @@ var DocParser = /** @class */ (function () {
     /**
      * Get all {@link ExportedSymbol}s from a file.
      */
-    DocParser.prototype.getExportedSymbols = function (fileName) {
-        var _this = this;
-        var symbols = [];
-        var sourceFile = this.program.getSourceFile(fileName);
+    getExportedSymbols(fileName) {
+        const symbols = [];
+        const sourceFile = this.program.getSourceFile(fileName);
         if (!sourceFile)
             return symbols;
-        find(sourceFile, function (node) {
-            var kind = node.kind;
+        find(sourceFile, node => {
+            const kind = node.kind;
             return ([
                 'VariableDeclaration',
                 'InterfaceDeclaration',
@@ -44,35 +31,38 @@ var DocParser = /** @class */ (function () {
                 'EnumDeclaration',
                 'ClassDeclaration',
             ]
-                .map(function (k) { return ts.SyntaxKind[k]; })
-                .includes(kind) && isNodeExported(_this.checker, node));
-        }).forEach(function (node) {
-            var symbol = getSymbolFromNode(_this.checker, node);
-            var previousSymbolsLength = _this.symbols.length;
+                .map(k => ts.SyntaxKind[k])
+                .includes(kind) && isNodeExported(this.checker, node));
+        }).forEach(node => {
+            const symbol = getSymbolFromNode(this.checker, node);
+            const previousSymbolsLength = this.symbols.length;
             if (symbol) {
-                var exportedSymbol = __assign(__assign({ name: symbol.name, fileName: fileName }, findDocComment(_this.checker, symbol)), { type: _this.getValueFromNode(node) });
+                const exportedSymbol = {
+                    name: symbol.name,
+                    fileName,
+                    ...findDocComment(this.checker, symbol),
+                    type: this.getValueFromNode(node),
+                };
                 symbols.push(exportedSymbol);
-                var addedSymbolsLength = previousSymbolsLength - _this.symbols.length;
+                const addedSymbolsLength = previousSymbolsLength - this.symbols.length;
                 // add all symbols added by the parser
                 if (addedSymbolsLength) {
-                    _this.symbols.slice(addedSymbolsLength).forEach(function (symbol) {
+                    this.symbols.slice(addedSymbolsLength).forEach(symbol => {
                         symbols.push(symbol);
                     });
                 }
-                _this.symbols.push(exportedSymbol);
+                this.symbols.push(exportedSymbol);
             }
         });
         return symbols;
-    };
-    DocParser.prototype.getValueFromNode = function (node) {
+    }
+    getValueFromNode(node) {
         return getValueFromNode(this, node);
-    };
-    DocParser.prototype.getValueFromType = function (type, node) {
+    }
+    getValueFromType(type, node) {
         return getValueFromType(this, type, node);
-    };
-    return DocParser;
-}());
-export { DocParser };
+    }
+}
 /**
  * This is the main recursive function for creating docs from the Typescript AST. The AST is
  * traversed and type information is extracted from source code. The Typescript type checker is used
@@ -90,7 +80,7 @@ function getValueFromNode(parser, node) {
         // This shouldn't happen, but we'd rather see `???` in the output than crash
         return unknownValue('???');
     }
-    return (parser.plugins.reduce(function (result, fn) {
+    return (parser.plugins.reduce((result, fn) => {
         return result || fn(node, parser);
     }, undefined) || _getValueFromNode(parser, node));
 }
@@ -99,7 +89,7 @@ function getValueFromNode(parser, node) {
  */
 function _getValueFromNode(parser, node) {
     var _a, _b, _c, _d, _e, _f;
-    var checker = parser.checker;
+    const { checker } = parser;
     // Uncomment for debugging
     // console.log(
     //   t.getKindNameFromNode(node) || node.kind,
@@ -119,7 +109,7 @@ function _getValueFromNode(parser, node) {
     if (t.isTupleType(node)) {
         return {
             kind: 'tuple',
-            value: node.elements.map(function (e) { return getValueFromNode(parser, e); }),
+            value: node.elements.map(e => getValueFromNode(parser, e)),
         };
     }
     /**
@@ -140,22 +130,22 @@ function _getValueFromNode(parser, node) {
     if ((t.isTypeAliasDeclaration(node) && t.isTypeLiteral(node.type)) ||
         t.isInterfaceDeclaration(node)) {
         // Treat Interfaces and Types with TypeLiterals as interfaces
-        var type = checker.getTypeAtLocation(node);
-        var properties = type
+        const type = checker.getTypeAtLocation(node);
+        const properties = type
             .getProperties()
-            .map(function (p) {
+            .map(p => {
             return getValueFromNode(parser, getValueDeclaration(p));
         })
             .filter(filterObjectProperties);
         // get index signature...
-        var indexType = getIndexSignatureFromType(parser, type);
+        const indexType = getIndexSignatureFromType(parser, type);
         if (isObject(type) && (properties.length || indexType)) {
-            var typeParameters = (_a = (node.typeParameters ||
-                node.parent.typeParameters)) === null || _a === void 0 ? void 0 : _a.map(function (p) { return getValueFromNode(parser, p); });
+            const typeParameters = (_a = (node.typeParameters ||
+                node.parent.typeParameters)) === null || _a === void 0 ? void 0 : _a.map(p => getValueFromNode(parser, p));
             return {
                 kind: 'object',
-                properties: properties,
-                typeParameters: typeParameters,
+                properties,
+                typeParameters,
                 indexSignature: indexType,
             };
         }
@@ -176,7 +166,7 @@ function _getValueFromNode(parser, node) {
      * ```
      */
     if (t.isTypeAliasDeclaration(node)) {
-        var typeParameters = (_b = node.typeParameters) === null || _b === void 0 ? void 0 : _b.map(function (p) { return getValueFromNode(parser, p); });
+        const typeParameters = (_b = node.typeParameters) === null || _b === void 0 ? void 0 : _b.map(p => getValueFromNode(parser, p));
         // We need to test if the `node.type` is a TypeReference and if that TypeReference is an exported
         // symbol. If the TypeReference is exported, we can continue with recursing on the `node.type`. If
         // it is not an exported symbol, we need to instead evaluate the type of the declaration directly using
@@ -190,15 +180,15 @@ function _getValueFromNode(parser, node) {
         // ```
         // If `ValueOf` was exported, the type would be documented as `ValueOf<{a: 'first', b:
         // 'second'}>`, but if it isn't exported, the value is `'first' | 'second'`
-        var isLocalTypeReference = t.isTypeReference(node.type) && !isExportedSymbol(checker, node.type.typeName);
-        var value = isLocalTypeReference
+        const isLocalTypeReference = t.isTypeReference(node.type) && !isExportedSymbol(checker, node.type.typeName);
+        const value = isLocalTypeReference
             ? getValueFromType(parser, checker.getTypeAtLocation(node), node) ||
                 unknownValue(safeGetText(checker, node))
             : getValueFromNode(parser, node.type);
         return {
             kind: 'type',
             typeParameters: typeParameters || [],
-            value: value,
+            value,
         };
     }
     /**
@@ -208,10 +198,10 @@ function _getValueFromNode(parser, node) {
      * ```
      */
     if (t.isClassDeclaration(node)) {
-        var type = checker.getTypeAtLocation(node);
-        var value = getObjectValueFromType(parser, type);
+        const type = checker.getTypeAtLocation(node);
+        const value = getObjectValueFromType(parser, type);
         if (value.kind === 'object') {
-            value.typeParameters = (_c = node.typeParameters) === null || _c === void 0 ? void 0 : _c.map(function (p) {
+            value.typeParameters = (_c = node.typeParameters) === null || _c === void 0 ? void 0 : _c.map(p => {
                 return getValueFromNode(parser, p);
             }).filter(filterObjectTypeParameters);
         }
@@ -231,12 +221,12 @@ function _getValueFromNode(parser, node) {
      * In this example, the TypeLiteral is `{ C: 'c' }`.
      */
     if (t.isTypeLiteral(node)) {
-        var properties = node.members
-            .map(function (member) {
+        const properties = node.members
+            .map(member => {
             return getValueFromNode(parser, member);
         })
             .filter(filterObjectProperties);
-        return { kind: 'object', properties: properties };
+        return { kind: 'object', properties };
     }
     /**
      * A ArrayType is a special notation for arrays. For example:
@@ -265,13 +255,13 @@ function _getValueFromNode(parser, node) {
      * The constraint is `string` and the default is `'a'`
      */
     if (t.isTypeParameter(node)) {
-        var constraint = node.constraint ? getValueFromNode(parser, node.constraint) : undefined;
-        var defaultValue = node.default ? getValueFromNode(parser, node.default) : undefined;
+        const constraint = node.constraint ? getValueFromNode(parser, node.constraint) : undefined;
+        const defaultValue = node.default ? getValueFromNode(parser, node.default) : undefined;
         return {
             kind: 'typeParameter',
             name: node.name.text,
-            defaultValue: defaultValue,
-            constraint: constraint,
+            defaultValue,
+            constraint,
             required: !defaultValue,
         };
     }
@@ -295,13 +285,19 @@ function _getValueFromNode(parser, node) {
      * as a `parameter` instead of a `function`
      */
     if (t.isMethodDeclaration(node)) {
-        var signature = getValueFromSignatureNode(parser, node);
-        var symbol_1 = getSymbolFromNode(checker, node);
-        var type = checker.getTypeAtLocation(node);
-        var jsDoc = findDocComment(checker, symbol_1);
+        const signature = getValueFromSignatureNode(parser, node);
+        const symbol = getSymbolFromNode(checker, node);
+        const type = checker.getTypeAtLocation(node);
+        const jsDoc = findDocComment(checker, symbol);
         if (jsDoc.tags.default) {
         }
-        return __assign({ kind: 'property', name: (symbol_1 === null || symbol_1 === void 0 ? void 0 : symbol_1.name) || '', type: signature, required: symbol_1 ? !isOptional(symbol_1) && !includesUndefined(type) : false }, jsDoc);
+        return {
+            kind: 'property',
+            name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || '',
+            type: signature,
+            required: symbol ? !isOptional(symbol) && !includesUndefined(type) : false,
+            ...jsDoc,
+        };
     }
     /**
      * A MethodSignature is a type of property declaration within a TS type. It is a special syntax
@@ -321,17 +317,22 @@ function _getValueFromNode(parser, node) {
      * of a `function`.
      */
     if (t.isMethodSignature(node)) {
-        var signature = getValueFromSignatureNode(parser, node);
-        var symbol_2 = getSymbolFromNode(checker, node);
-        var jsDoc = findDocComment(checker, symbol_2);
-        return __assign({ kind: 'property', name: (symbol_2 === null || symbol_2 === void 0 ? void 0 : symbol_2.name) || node.name.text || '', type: signature }, jsDoc);
+        const signature = getValueFromSignatureNode(parser, node);
+        const symbol = getSymbolFromNode(checker, node);
+        const jsDoc = findDocComment(checker, symbol);
+        return {
+            kind: 'property',
+            name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || node.name.text || '',
+            type: signature,
+            ...jsDoc,
+        };
     }
     /**
      * A FunctionType is a function declaration in Typescript's type annotation
      */
     if (t.isFunctionType(node)) {
-        var declaration = node;
-        var signature = checker.getSignatureFromDeclaration(declaration);
+        const declaration = node;
+        const signature = checker.getSignatureFromDeclaration(declaration);
         if (signature) {
             return getValueFromSignature(parser, node, signature);
         }
@@ -368,11 +369,11 @@ function _getValueFromNode(parser, node) {
         if (node.initializer &&
             t.isIdentifier(node.initializer) &&
             isExportedSymbol(checker, node.initializer)) {
-            var symbol_3 = getSymbolFromNode(checker, node.initializer);
+            const symbol = getSymbolFromNode(checker, node.initializer);
             return {
                 kind: 'symbol',
                 name: node.initializer.text,
-                fileName: (_d = symbol_3 === null || symbol_3 === void 0 ? void 0 : symbol_3.valueDeclaration) === null || _d === void 0 ? void 0 : _d.getSourceFile().fileName,
+                fileName: (_d = symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) === null || _d === void 0 ? void 0 : _d.getSourceFile().fileName,
             };
         }
         if (node.initializer && ts.isFunctionLike(node.initializer)) {
@@ -380,7 +381,7 @@ function _getValueFromNode(parser, node) {
         }
         // We have no type information in the AST. We'll get the Type from the type checker and run some
         // tests on what we have
-        var type = checker.getTypeAtLocation(node.initializer || node);
+        const type = checker.getTypeAtLocation(node.initializer || node);
         // Both functions and objects are considered objects to Typescript
         if (isObject(type)) {
             if (type.objectFlags & ts.ObjectFlags.ArrayLiteral) {
@@ -388,7 +389,7 @@ function _getValueFromNode(parser, node) {
             }
             return getObjectValueFromType(parser, type);
         }
-        var value = getValueFromType(parser, type);
+        const value = getValueFromType(parser, type);
         if (value)
             return value;
     }
@@ -401,18 +402,24 @@ function _getValueFromNode(parser, node) {
      * }
      */
     if (t.isPropertySignature(node)) {
-        var symbol_4 = getSymbolFromNode(checker, node);
-        var jsDoc = findDocComment(checker, symbol_4);
+        const symbol = getSymbolFromNode(checker, node);
+        const jsDoc = findDocComment(checker, symbol);
         // Get the name of the property - it could be a symbol or have a `name` that is an identifier or string literal
-        var name_1 = (symbol_4 === null || symbol_4 === void 0 ? void 0 : symbol_4.name) ||
+        const name = (symbol === null || symbol === void 0 ? void 0 : symbol.name) ||
             (t.isIdentifier(node.name)
                 ? node.name.text
                 : t.isStringLiteral(node.name)
                     ? node.name.text
                     : '');
-        return __assign({ kind: 'property', name: name_1, required: node.questionToken ? false : true, type: node.type
+        return {
+            kind: 'property',
+            name,
+            required: node.questionToken ? false : true,
+            type: node.type
                 ? getValueFromNode(parser, node.type)
-                : unknownValue(safeGetText(checker, node)) }, jsDoc);
+                : unknownValue(safeGetText(checker, node)),
+            ...jsDoc,
+        };
     }
     /**
      * A PropertyDeclaration is a property declared in a class
@@ -426,11 +433,16 @@ function _getValueFromNode(parser, node) {
      * In this example, the PropertyDeclaration is `a = 'b'`
      */
     if (t.isPropertyDeclaration(node)) {
-        var name_2 = getNodeName(node);
-        var symbol_5 = getSymbolFromNode(checker, node);
-        var jsDoc = findDocComment(checker, symbol_5);
-        var type = checker.getTypeAtLocation(node);
-        return __assign({ kind: 'property', name: name_2 || (symbol_5 === null || symbol_5 === void 0 ? void 0 : symbol_5.name) || 'unknown', type: getValueFromType(parser, type) || unknownValue(safeGetText(checker, node)) }, jsDoc);
+        const name = getNodeName(node);
+        const symbol = getSymbolFromNode(checker, node);
+        const jsDoc = findDocComment(checker, symbol);
+        const type = checker.getTypeAtLocation(node);
+        return {
+            kind: 'property',
+            name: name || (symbol === null || symbol === void 0 ? void 0 : symbol.name) || 'unknown',
+            type: getValueFromType(parser, type) || unknownValue(safeGetText(checker, node)),
+            ...jsDoc,
+        };
     }
     /**
      * An ObjectLiteralExpression is a JS value of an object literal.
@@ -448,8 +460,8 @@ function _getValueFromNode(parser, node) {
         return {
             kind: 'object',
             properties: node.properties
-                .flatMap(function (property) {
-                var value = getValueFromNode(parser, property);
+                .flatMap(property => {
+                const value = getValueFromNode(parser, property);
                 if (value.kind === 'object') {
                     return value.properties;
                 }
@@ -465,35 +477,35 @@ function _getValueFromNode(parser, node) {
         };
     }
     if (t.isSpreadAssignment(node)) {
-        var symbol_6 = getSymbolFromNode(checker, node.expression);
-        var declaration = getValueDeclaration(symbol_6);
+        const symbol = getSymbolFromNode(checker, node.expression);
+        const declaration = getValueDeclaration(symbol);
         if (declaration) {
             return getValueFromNode(parser, declaration);
         }
     }
     if (t.isArrayLiteralExpression(node)) {
-        var values_1 = [];
-        node.elements.forEach(function (element) {
+        let values = [];
+        node.elements.forEach(element => {
             if (t.isSpreadElement(element)) {
                 t.getKindNameFromNode(element);
-                var value = getValueFromNode(parser, element);
+                const value = getValueFromNode(parser, element);
                 if (value.kind === 'array' || value.kind === 'tuple') {
-                    values_1 = values_1.concat(value.value);
+                    values = values.concat(value.value);
                 }
             }
             else {
-                var value = getValueFromNode(parser, element);
-                values_1.push(value);
+                const value = getValueFromNode(parser, element);
+                values.push(value);
             }
         });
         return {
             kind: 'tuple',
-            value: values_1,
+            value: values,
         };
     }
     if (t.isSpreadElement(node)) {
-        var symbol_7 = getSymbolFromNode(checker, node.expression);
-        var declaration = getValueDeclaration(symbol_7);
+        const symbol = getSymbolFromNode(checker, node.expression);
+        const declaration = getValueDeclaration(symbol);
         if (declaration) {
             return getValueFromNode(parser, declaration);
         }
@@ -510,20 +522,27 @@ function _getValueFromNode(parser, node) {
      *
      * */
     if (t.isPropertyAssignment(node)) {
-        var type = checker.getTypeAtLocation(node);
-        var symbol_8 = getSymbolFromNode(checker, node);
-        var jsDoc = findDocComment(checker, symbol_8);
+        const type = checker.getTypeAtLocation(node);
+        const symbol = getSymbolFromNode(checker, node);
+        const jsDoc = findDocComment(checker, symbol);
         // For default values, we want the value and not the type. An `AsExpression` redirects to types,
         // so we want to bypass it to get the value node
-        var defaultValueNode = t.isAsExpression(node.initializer)
+        const defaultValueNode = t.isAsExpression(node.initializer)
             ? node.initializer.expression
             : node.initializer;
-        return __assign({ kind: 'property', name: (symbol_8 === null || symbol_8 === void 0 ? void 0 : symbol_8.name) || '', defaultValue: getValueFromNode(parser, defaultValueNode), type: getValueFromType(parser, type) || unknownValue(safeGetText(checker, node)), required: symbol_8 ? !isOptional(symbol_8) && !includesUndefined(type) : false }, jsDoc);
+        return {
+            kind: 'property',
+            name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || '',
+            defaultValue: getValueFromNode(parser, defaultValueNode),
+            type: getValueFromType(parser, type) || unknownValue(safeGetText(checker, node)),
+            required: symbol ? !isOptional(symbol) && !includesUndefined(type) : false,
+            ...jsDoc,
+        };
     }
     // as A
     if (t.isAsExpression(node)) {
         if (safeGetText(checker, node) === 'const') {
-            var type = checker.getTypeAtLocation(node.parent);
+            const type = checker.getTypeAtLocation(node.parent);
             return getValueFromType(parser, type) || unknownValue(safeGetText(checker, node));
         }
         return getValueFromNode(parser, node.type);
@@ -533,16 +552,16 @@ function _getValueFromNode(parser, node) {
         // something like `keyof A`. In this case, we'll get the symbol and ask for the properties of
         // the symbol's declaration.
         if (t.isTypeReference(node.type)) {
-            var symbol_9 = getSymbolFromNode(checker, node.type.typeName);
-            var declaration = getValueDeclaration(symbol_9);
-            if (symbol_9 && declaration && isExportedSymbol(checker, declaration)) {
+            const symbol = getSymbolFromNode(checker, node.type.typeName);
+            const declaration = getValueDeclaration(symbol);
+            if (symbol && declaration && isExportedSymbol(checker, declaration)) {
                 return {
                     kind: 'keyof',
                     name: {
                         kind: 'symbol',
-                        name: symbol_9.name,
+                        name: symbol.name,
                         fileName: declaration.getSourceFile().fileName,
-                        value: "keyof " + symbol_9.name,
+                        value: `keyof ${symbol.name}`,
                     },
                 };
             }
@@ -620,21 +639,21 @@ function _getValueFromNode(parser, node) {
     }
     // type A = `{anything}`
     if (t.isTemplateLiteralType(node)) {
-        var type = checker.getTypeAtLocation(node);
+        const type = checker.getTypeAtLocation(node);
         return getValueFromType(parser, type, node) || unknownValue(checker.typeToString(type));
     }
     // A | B
     if (t.isUnionType(node)) {
         return {
             kind: 'union',
-            value: node.types.map(function (type) { return getValueFromNode(parser, type); }),
+            value: node.types.map(type => getValueFromNode(parser, type)),
         };
     }
     // A & B
     if (t.isIntersectionType(node)) {
         return {
             kind: 'intersection',
-            value: node.types.map(function (type) { return getValueFromNode(parser, type); }),
+            value: node.types.map(type => getValueFromNode(parser, type)),
         };
     }
     // ()
@@ -643,7 +662,7 @@ function _getValueFromNode(parser, node) {
     }
     // type A = B['C']
     if (t.isIndexedAccessType(node)) {
-        var type = checker.getTypeAtLocation(node);
+        const type = checker.getTypeAtLocation(node);
         return getValueFromType(parser, type, node) || unknownValue(safeGetText(checker, node));
     }
     /**
@@ -684,15 +703,15 @@ function _getValueFromNode(parser, node) {
      */
     if (t.isQualifiedName(node)) {
         if (isExportedSymbol(checker, node.left)) {
-            var value = checker.typeToString(checker.getTypeAtLocation(node.left));
+            const value = checker.typeToString(checker.getTypeAtLocation(node.left));
             return {
                 kind: 'qualifiedName',
-                left: { kind: 'symbol', name: safeGetText(checker, node.left), value: value },
+                left: { kind: 'symbol', name: safeGetText(checker, node.left), value },
                 right: { kind: 'string', value: safeGetText(checker, node.right) },
             };
         }
         // if the node.left is not exported, we'll reduce to a type
-        var type = checker.getTypeAtLocation(node);
+        const type = checker.getTypeAtLocation(node);
         return getValueFromType(parser, type, node) || unknownValue(checker.typeToString(type));
     }
     /**
@@ -707,12 +726,12 @@ function _getValueFromNode(parser, node) {
      */
     if (t.isTypeQuery(node)) {
         if (isExportedSymbol(checker, node.exprName)) {
-            var value = checker.typeToString(checker.getTypeAtLocation(node.exprName));
-            return { kind: 'symbol', name: node.exprName.getText(), value: value };
+            const value = checker.typeToString(checker.getTypeAtLocation(node.exprName));
+            return { kind: 'symbol', name: node.exprName.getText(), value };
         }
-        var symbol_10 = getSymbolFromNode(checker, node.exprName);
-        if (symbol_10) {
-            var declaration = getValueDeclaration(symbol_10);
+        const symbol = getSymbolFromNode(checker, node.exprName);
+        if (symbol) {
+            const declaration = getValueDeclaration(symbol);
             return getValueFromNode(parser, declaration);
         }
     }
@@ -728,11 +747,11 @@ function _getValueFromNode(parser, node) {
      * add additional properties on the function.
      */
     if (t.isPropertyAccessExpression(node)) {
-        var typeInfo = void 0;
+        let typeInfo;
         if (t.isAsExpression(node.name)) {
             typeInfo = getValueFromNode(parser, node.name);
         }
-        var type = checker.getTypeAtLocation(node);
+        const type = checker.getTypeAtLocation(node);
         typeInfo = getValueFromType(parser, type) || unknownValue(checker.typeToString(type));
         return { kind: 'property', name: node.name.getText(), type: typeInfo };
     }
@@ -753,25 +772,25 @@ function _getValueFromNode(parser, node) {
     if (t.isTypeReference(node)) {
         // handle `as const` specially. If we don't do this, we'll get into an infinite loop
         if (safeGetText(checker, node) === 'const') {
-            var type_1 = checker.getTypeAtLocation(node.parent.parent);
-            return getValueFromType(parser, type_1) || unknownValue(node.parent.parent.getText());
+            const type = checker.getTypeAtLocation(node.parent.parent);
+            return getValueFromType(parser, type) || unknownValue(node.parent.parent.getText());
         }
-        var typeParameters = (_e = node.typeArguments) === null || _e === void 0 ? void 0 : _e.map(function (p) { return getValueFromNode(parser, p); });
-        var symbolNode = t.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName;
-        var symbol_11 = getSymbolFromNode(checker, symbolNode);
-        var fileName = (_f = getValueDeclaration(symbol_11)) === null || _f === void 0 ? void 0 : _f.getSourceFile().fileName;
-        var externalSymbol = getExternalSymbol((symbol_11 === null || symbol_11 === void 0 ? void 0 : symbol_11.name) || safeGetText(checker, node), fileName);
+        const typeParameters = (_e = node.typeArguments) === null || _e === void 0 ? void 0 : _e.map(p => getValueFromNode(parser, p));
+        const symbolNode = t.isQualifiedName(node.typeName) ? node.typeName.right : node.typeName;
+        const symbol = getSymbolFromNode(checker, symbolNode);
+        const fileName = (_f = getValueDeclaration(symbol)) === null || _f === void 0 ? void 0 : _f.getSourceFile().fileName;
+        const externalSymbol = getExternalSymbol((symbol === null || symbol === void 0 ? void 0 : symbol.name) || safeGetText(checker, node), fileName);
         if (externalSymbol) {
             return {
                 kind: 'external',
-                name: (symbol_11 === null || symbol_11 === void 0 ? void 0 : symbol_11.name) || '',
+                name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || '',
                 url: externalSymbol,
-                typeParameters: typeParameters,
+                typeParameters,
             };
         }
         if (isExportedSymbol(checker, symbolNode)) {
-            var value = checker.typeToString(checker.getTypeAtLocation(node.typeName));
-            return { kind: 'symbol', name: safeGetText(checker, node.typeName), typeParameters: typeParameters, value: value };
+            const value = checker.typeToString(checker.getTypeAtLocation(node.typeName));
+            return { kind: 'symbol', name: safeGetText(checker, node.typeName), typeParameters, value };
         }
         // If it is a qualified name, handle that specially. The `left` might be a symbol
         if (t.isQualifiedName(node.typeName)) {
@@ -779,15 +798,15 @@ function _getValueFromNode(parser, node) {
         }
         // The TypeReference isn't exported, so we'll return the type of the
         // symbol's value declaration directly
-        var type = checker.getTypeAtLocation(node);
-        if (symbol_11) {
+        const type = checker.getTypeAtLocation(node);
+        if (symbol) {
             if (type.getFlags() & ts.TypeFlags.Instantiable) {
                 // It is a generic type
-                return { kind: 'generic', name: symbol_11 === null || symbol_11 === void 0 ? void 0 : symbol_11.name };
+                return { kind: 'generic', name: symbol === null || symbol === void 0 ? void 0 : symbol.name };
             }
-            var declaration = getValueDeclaration(symbol_11);
+            const declaration = getValueDeclaration(symbol);
             if (declaration) {
-                var typeInfo = getValueFromNode(parser, declaration);
+                const typeInfo = getValueFromNode(parser, declaration);
                 // we want to embed objects
                 if (typeInfo.kind === 'object') {
                     return typeInfo;
@@ -818,11 +837,16 @@ function _getValueFromNode(parser, node) {
      * points to the VariableDeclaration.
      */
     if (t.isShorthandPropertyAssignment(node)) {
-        var type = checker.getTypeAtLocation(node);
-        var symbol_12 = getSymbolFromNode(checker, node);
-        var jsDoc = findDocComment(checker, symbol_12);
+        const type = checker.getTypeAtLocation(node);
+        const symbol = getSymbolFromNode(checker, node);
+        const jsDoc = findDocComment(checker, symbol);
         // see if the declaration is assigned to something exported
-        return __assign({ kind: 'property', name: (symbol_12 === null || symbol_12 === void 0 ? void 0 : symbol_12.name) || '', type: getValueFromType(parser, type) || unknownValue(safeGetText(checker, node)) }, jsDoc);
+        return {
+            kind: 'property',
+            name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || '',
+            type: getValueFromType(parser, type) || unknownValue(safeGetText(checker, node)),
+            ...jsDoc,
+        };
     }
     /**
      * Declaration of a enum
@@ -839,7 +863,7 @@ function _getValueFromNode(parser, node) {
         return {
             kind: 'object',
             typeParameters: [],
-            properties: node.members.map(function (m, index) {
+            properties: node.members.map((m, index) => {
                 return {
                     kind: 'property',
                     name: safeGetText(checker, m.name),
@@ -865,8 +889,8 @@ function _getValueFromNode(parser, node) {
      */
     if (t.isIdentifier(node)) {
         if (isExportedSymbol(checker, node)) {
-            var symbol_13 = getSymbolFromNode(checker, node);
-            var declaration = getValueDeclaration(symbol_13);
+            const symbol = getSymbolFromNode(checker, node);
+            const declaration = getValueDeclaration(symbol);
             return {
                 kind: 'symbol',
                 name: node.text,
@@ -882,20 +906,20 @@ function _getValueFromNode(parser, node) {
      *
      */
     if (t.isParameter(node)) {
-        var type = checker.getTypeAtLocation(node);
-        var symbol_14 = getSymbolFromNode(checker, node);
-        var jsDoc = findDocComment(checker, symbol_14);
-        var isRequired = node.questionToken
+        const type = checker.getTypeAtLocation(node);
+        const symbol = getSymbolFromNode(checker, node);
+        const jsDoc = findDocComment(checker, symbol);
+        const isRequired = node.questionToken
             ? false
             : node.initializer
                 ? false
-                : symbol_14
-                    ? !isOptional(symbol_14) && !includesUndefined(type)
+                : symbol
+                    ? !isOptional(symbol) && !includesUndefined(type)
                     : false;
-        var typeInfo = node.type
+        const typeInfo = node.type
             ? getValueFromNode(parser, node.type)
             : getValueFromType(parser, type) || unknownValue(safeGetText(checker, node));
-        var defaultValue = node.initializer ? getValueFromNode(parser, node.initializer) : undefined;
+        const defaultValue = node.initializer ? getValueFromNode(parser, node.initializer) : undefined;
         /**
          * Set default values if an object binding pattern is found. We do this at the Parameter level,
          * because we have all the info here.
@@ -908,29 +932,37 @@ function _getValueFromNode(parser, node) {
          * In this example, the ObjectBindingPattern is `{ a = 'a', b }`
          */
         if (t.isObjectBindingPattern(node.name)) {
-            var defaults_1 = getDefaultsFromObjectBindingParameter(parser, node);
+            const defaults = getDefaultsFromObjectBindingParameter(parser, node);
             if (typeInfo.kind === 'object') {
-                typeInfo.properties.forEach(function (p) {
-                    if (!p.defaultValue && defaults_1[p.name]) {
-                        p.defaultValue = defaults_1[p.name];
+                typeInfo.properties.forEach(p => {
+                    if (!p.defaultValue && defaults[p.name]) {
+                        p.defaultValue = defaults[p.name];
                     }
                 });
             }
         }
-        return __assign({ kind: 'parameter', name: (symbol_14 === null || symbol_14 === void 0 ? void 0 : symbol_14.name) || '', defaultValue: defaultValue, type: typeInfo, required: isRequired, rest: !!node.dotDotDotToken }, jsDoc);
+        return {
+            kind: 'parameter',
+            name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || '',
+            defaultValue,
+            type: typeInfo,
+            required: isRequired,
+            rest: !!node.dotDotDotToken,
+            ...jsDoc,
+        };
     }
     /**
      * A call expression is an expression calling a function. In this case, we want to get the signature
      * and get a type for the return type
      */
     if (t.isCallExpression(node)) {
-        var type = checker.getTypeAtLocation(node);
-        var value = getValueFromType(parser, type);
+        const type = checker.getTypeAtLocation(node);
+        const value = getValueFromType(parser, type);
         if (value) {
             return value;
         }
     }
-    var symbol = getSymbolFromNode(checker, node);
+    const symbol = getSymbolFromNode(checker, node);
     if (!symbol) {
         return unknownValue(safeGetText(checker, node));
     }
@@ -940,7 +972,7 @@ function _getValueFromNode(parser, node) {
 function isNodeExported(checker, node) {
     return (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0;
 }
-export var defaultJSDoc = {
+export const defaultJSDoc = {
     description: '',
     tags: {},
     declarations: [],
@@ -950,37 +982,37 @@ export function getFullJsDocComment(checker, symbol) {
     if (symbol.getDocumentationComment === undefined) {
         return defaultJSDoc;
     }
-    var mainComment = ts.displayPartsToString(symbol.getDocumentationComment(checker));
+    let mainComment = ts.displayPartsToString(symbol.getDocumentationComment(checker));
     if (mainComment) {
         mainComment = mainComment.replace(/\r\n/g, '\n');
     }
-    var tags = symbol.getJsDocTags() || [];
-    var tagMap = {};
-    tags.forEach(function (tag) {
-        var trimmedText = (tag.text || '').trim();
-        var currentValue = tagMap[tag.name];
+    const tags = symbol.getJsDocTags() || [];
+    const tagMap = {};
+    tags.forEach(tag => {
+        const trimmedText = (tag.text || '').trim();
+        const currentValue = tagMap[tag.name];
         tagMap[tag.name] = currentValue ? currentValue + '\n' + trimmedText : trimmedText;
     });
     return {
         description: mainComment,
-        declarations: ((_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) !== null && _a !== void 0 ? _a : []).map(function (d) { return ({
+        declarations: ((_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) !== null && _a !== void 0 ? _a : []).map(d => ({
             name: (symbol === null || symbol === void 0 ? void 0 : symbol.name) || '',
             filePath: d.getSourceFile().fileName,
-        }); }),
+        })),
         tags: tagMap,
     };
 }
 export function findDocComment(checker, symbol) {
     if (symbol) {
-        var comment_1 = getFullJsDocComment(checker, symbol);
-        if (comment_1.description || comment_1.declarations.length || comment_1.tags.default) {
-            return comment_1;
+        const comment = getFullJsDocComment(checker, symbol);
+        if (comment.description || comment.declarations.length || comment.tags.default) {
+            return comment;
         }
-        var rootSymbols = checker.getRootSymbols(symbol);
-        var commentsOnRootSymbols = rootSymbols
-            .filter(function (x) { return x !== symbol; })
-            .map(function (x) { return getFullJsDocComment(checker, x); })
-            .filter(function (x) { return !!x.description || !!comment_1.tags.default; });
+        const rootSymbols = checker.getRootSymbols(symbol);
+        const commentsOnRootSymbols = rootSymbols
+            .filter(x => x !== symbol)
+            .map(x => getFullJsDocComment(checker, x))
+            .filter(x => !!x.description || !!comment.tags.default);
         if (commentsOnRootSymbols.length) {
             return commentsOnRootSymbols[0];
         }
@@ -991,7 +1023,7 @@ export function findDocComment(checker, symbol) {
  * Attempt to get the name of a declaration or expression
  */
 export function getNodeName(node) {
-    var name = ts.getNameOfDeclaration(node);
+    const name = ts.getNameOfDeclaration(node);
     if (name && 'text' in name) {
         return name.text;
     }
@@ -1014,7 +1046,7 @@ export function isObject(type) {
     return !!(type.flags & ts.TypeFlags.Object);
 }
 function includesUndefined(type) {
-    return type.isUnion() ? type.types.some(function (t) { return t.flags & ts.TypeFlags.Undefined; }) : false;
+    return type.isUnion() ? type.types.some(t => t.flags & ts.TypeFlags.Undefined) : false;
 }
 function isTupleType(type) {
     var _a;
@@ -1051,9 +1083,9 @@ export function getValidDefaultFromNode(parser, node) {
  */
 export function getDefaultsFromObjectBindingParameter(parser, node) {
     if (t.isObjectBindingPattern(node.name)) {
-        return node.name.elements.reduce(function (result, element) {
+        return node.name.elements.reduce((result, element) => {
             if (t.isBindingElement(element) && t.isIdentifier(element.name) && element.initializer) {
-                var defaultValue = getValidDefaultFromNode(parser, element.initializer);
+                const defaultValue = getValidDefaultFromNode(parser, element.initializer);
                 if (defaultValue) {
                     result[element.name.text] = defaultValue;
                 }
@@ -1081,11 +1113,11 @@ export function getDefaultsFromObjectBindingParameter(parser, node) {
  */
 function getIndexSignatureFromType(parser, type) {
     var _a;
-    var checker = parser.checker;
-    var indexSignature = checker.getIndexInfoOfType(type, ts.IndexKind.String) ||
+    const { checker } = parser;
+    const indexSignature = checker.getIndexInfoOfType(type, ts.IndexKind.String) ||
         checker.getIndexInfoOfType(type, ts.IndexKind.Number);
     if (indexSignature) {
-        var parameter = (_a = indexSignature.declaration) === null || _a === void 0 ? void 0 : _a.parameters[0];
+        const parameter = (_a = indexSignature.declaration) === null || _a === void 0 ? void 0 : _a.parameters[0];
         return {
             kind: 'indexSignature',
             name: (parameter === null || parameter === void 0 ? void 0 : parameter.name) ? safeGetText(checker, parameter === null || parameter === void 0 ? void 0 : parameter.name) : '',
@@ -1107,23 +1139,23 @@ function getIndexSignatureFromType(parser, type) {
  * infinite loops.
  */
 export function getValueFromType(parser, type, node) {
-    var checker = parser.checker;
-    var originalNodeKind = node === null || node === void 0 ? void 0 : node.kind;
-    var typeToString = checker.typeToString(type);
+    const { checker } = parser;
+    const originalNodeKind = node === null || node === void 0 ? void 0 : node.kind;
+    const typeToString = checker.typeToString(type);
     // If the type is `any`, we want to bail now
     if (type.flags & ts.TypeFlags.Any) {
         return { kind: 'primitive', value: 'any' };
     }
     // check if the node is an external symbol
     // TODO: This won't work if the symbol contains a generic
-    var externalSymbol = getExternalSymbol(typeToString);
+    const externalSymbol = getExternalSymbol(typeToString);
     if (externalSymbol) {
         return { kind: 'external', name: typeToString, url: externalSymbol };
     }
     if (isTupleType(type)) {
         return {
             kind: 'union',
-            value: checker.getTypeArguments(type).map(function (t) { return getValueFromType(parser, t) || unknownValue(''); }) ||
+            value: checker.getTypeArguments(type).map(t => getValueFromType(parser, t) || unknownValue('')) ||
                 [],
         };
     }
@@ -1150,20 +1182,20 @@ export function getValueFromType(parser, type, node) {
     // service uses for the tooltips when hovering over text in your IDE. We try to go from Type to
     // Node whenever possible, but there are some cases where interacting directly with the types is
     // preferred. The union example is one of such examples.
-    var typeNode = checker.typeToTypeNode(type, node, ts.NodeBuilderFlags.NoTruncation);
+    const typeNode = checker.typeToTypeNode(type, node, ts.NodeBuilderFlags.NoTruncation);
     // We try to extract useful type information from the TypeNode and go back to recursing the AST.
     // But, if the typeNode and original node have the same kind, we've actually lost information and
     // should skip processing the TypeNode.
     if (typeNode && originalNodeKind !== typeNode.kind) {
         // find the symbol
         if (t.isTypeReference(typeNode)) {
-            var symbol = getSymbolFromNode(checker, typeNode.typeName);
-            var declaration = getValueDeclaration(symbol);
-            var fileName = declaration === null || declaration === void 0 ? void 0 : declaration.getSourceFile().fileName;
+            const symbol = getSymbolFromNode(checker, typeNode.typeName);
+            const declaration = getValueDeclaration(symbol);
+            const fileName = declaration === null || declaration === void 0 ? void 0 : declaration.getSourceFile().fileName;
             if (symbol) {
-                var externalSymbol_1 = getExternalSymbol(symbol.name, fileName);
-                if (externalSymbol_1) {
-                    return { kind: 'external', name: symbol.name, url: externalSymbol_1 };
+                const externalSymbol = getExternalSymbol(symbol.name, fileName);
+                if (externalSymbol) {
+                    return { kind: 'external', name: symbol.name, url: externalSymbol };
                 }
                 if (declaration && declaration !== node) {
                     if (isExportedSymbol(checker, declaration)) {
@@ -1176,18 +1208,16 @@ export function getValueFromType(parser, type, node) {
         // Figure out if we should recurse back into AST nodes with our synthetic TypeNode. There are
         // exceptions to using the TypeNode. Exceptions where we actually lose type information. Some
         // examples are large unions or `keyof`:
-        var exceptions = false;
+        let exceptions = false;
         // The typeNode is a UnionType, but the number of items has overflowed with an identifier `...
         // {N} more ...`, so we don't want to use the typeNode and will use `type.types` instead which
         // is not shortened. In this case we want to do nothing and use the type-based union check
         if (t.isUnionType(typeNode) &&
             type.isUnion() &&
-            typeNode.types.some(function (v) {
-                return t.isIdentifier(v) ||
-                    (t.isTypeReference(v) &&
-                        t.isIdentifier(v.typeName) &&
-                        v.typeName.escapedText.includes('more'));
-            })) {
+            typeNode.types.some(v => t.isIdentifier(v) ||
+                (t.isTypeReference(v) &&
+                    t.isIdentifier(v.typeName) &&
+                    v.typeName.escapedText.includes('more')))) {
             exceptions = true;
         }
         // A function TypeNode looses a lot of information. We'll fallback to using the type. A Function
@@ -1230,10 +1260,10 @@ export function getValueFromType(parser, type, node) {
     if (type.isUnion()) {
         // If we got here, it means a TypeNode was a TypeReference that wasn't exported or a synthetic
         // TypeNode `keyof *` that `getValueFromNode` couldn't properly parse.
-        var filteredTypes = type.types;
+        let filteredTypes = type.types;
         return {
             kind: 'union',
-            value: filteredTypes.map(function (t) { return getValueFromType(parser, t) || unknownValue(checker.typeToString(t)); }),
+            value: filteredTypes.map(t => getValueFromType(parser, t) || unknownValue(checker.typeToString(t))),
         };
     }
     if (type.isStringLiteral()) {
@@ -1268,9 +1298,9 @@ export function getValueFromType(parser, type, node) {
     }
     if (isObject(type)) {
         if (type.objectFlags & ts.ObjectFlags.ArrayLiteral) {
-            var typeNode_1 = checker.typeToTypeNode(type, undefined, undefined);
-            if (typeNode_1) {
-                return getValueFromNode(parser, typeNode_1);
+            const typeNode = checker.typeToTypeNode(type, undefined, undefined);
+            if (typeNode) {
+                return getValueFromNode(parser, typeNode);
             }
         }
         return getObjectValueFromType(parser, type);
@@ -1282,12 +1312,12 @@ export function unknownValue(nodeText) {
 }
 export function isExportedSymbol(checker, node) {
     var _a;
-    var sourceFile = (_a = node.getSourceFile) === null || _a === void 0 ? void 0 : _a.call(node);
+    const sourceFile = (_a = node.getSourceFile) === null || _a === void 0 ? void 0 : _a.call(node);
     if (sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.isDeclarationFile) {
         return true;
     }
-    var symbol = getSymbolFromNode(checker, node);
-    var declarationNode = getValueDeclaration(symbol);
+    const symbol = getSymbolFromNode(checker, node);
+    const declarationNode = getValueDeclaration(symbol);
     if (declarationNode) {
         t.getKindNameFromNode(declarationNode);
         // Check if the declaration's sourcefile is a declaration file
@@ -1322,8 +1352,8 @@ function safeGetText(checker, node) {
         return node.text;
     }
     // Try a symbol
-    var symbol = getSymbolFromNode(checker, node);
-    return (symbol === null || symbol === void 0 ? void 0 : symbol.name) || "SyntheticNode - " + t.getKindNameFromNode(node);
+    const symbol = getSymbolFromNode(checker, node);
+    return (symbol === null || symbol === void 0 ? void 0 : symbol.name) || `SyntheticNode - ${t.getKindNameFromNode(node)}`;
 }
 /**
  * Get export members of a node. Export members are additional members of a declaration.
@@ -1337,64 +1367,64 @@ function safeGetText(checker, node) {
  */
 function getExportMembers(parser, node) {
     var _a;
-    var checker = parser.checker;
-    var exports = ((_a = getSymbolFromNode(checker, node)) === null || _a === void 0 ? void 0 : _a.exports) || new Map();
-    var members = Array.from(exports.values())
-        .map(function (symbol) {
-        var declaration = getValueDeclaration(symbol);
+    const { checker } = parser;
+    const exports = ((_a = getSymbolFromNode(checker, node)) === null || _a === void 0 ? void 0 : _a.exports) || new Map();
+    const members = Array.from(exports.values())
+        .map(symbol => {
+        const declaration = getValueDeclaration(symbol);
         if (declaration) {
             return getValueFromNode(parser, declaration);
         }
         return;
     })
-        .filter(function (i) { return !!i; });
+        .filter((i) => !!i);
     return members;
 }
 function getValueFromSignature(parser, declaration, signature) {
     var _a;
-    var members = getExportMembers(parser, declaration);
-    var typeParameters = (_a = signature.typeParameters) === null || _a === void 0 ? void 0 : _a.map(function (p) { return getValueFromType(parser, p); }).filter(function (v) { return (v === null || v === void 0 ? void 0 : v.kind) === 'typeParameter'; });
-    var parameters = signature.parameters.map(function (s) {
+    const members = getExportMembers(parser, declaration);
+    const typeParameters = (_a = signature.typeParameters) === null || _a === void 0 ? void 0 : _a.map(p => getValueFromType(parser, p)).filter((v) => (v === null || v === void 0 ? void 0 : v.kind) === 'typeParameter');
+    const parameters = signature.parameters.map(s => {
         return getValueFromNode(parser, getValueDeclaration(s));
     });
-    var returnType = declaration.type
+    const returnType = declaration.type
         ? getValueFromNode(parser, declaration.type)
         : getValueFromType(parser, signature.getReturnType()) || unknownValue(declaration.getText());
     return {
         kind: 'function',
-        typeParameters: typeParameters,
-        parameters: parameters,
-        members: members,
-        returnType: returnType,
+        typeParameters,
+        parameters,
+        members,
+        returnType,
     };
 }
 function generateSignatureFromTypeNode(parser, node) {
     var _a;
     if (t.isFunctionType(node) || t.isMethodSignature(node)) {
-        var parameters_1 = node.parameters.map(function (p) { return (getSymbolFromNode(parser.checker, p) || getSymbolFromNode(parser.checker, p.name)); });
-        var typeParameters_1 = (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.map(function (t) { return parser.checker.getTypeAtLocation(t); });
+        const parameters = node.parameters.map(p => (getSymbolFromNode(parser.checker, p) || getSymbolFromNode(parser.checker, p.name)));
+        const typeParameters = (_a = node.typeParameters) === null || _a === void 0 ? void 0 : _a.map(t => parser.checker.getTypeAtLocation(t));
         return {
-            parameters: parameters_1,
+            parameters,
             declaration: node,
-            typeParameters: typeParameters_1,
-            getDeclaration: function () {
+            typeParameters,
+            getDeclaration() {
                 return node;
             },
-            getParameters: function () {
-                return parameters_1;
+            getParameters() {
+                return parameters;
             },
-            getTypeParameters: function () {
-                return typeParameters_1;
+            getTypeParameters() {
+                return typeParameters;
             },
-            getReturnType: function () {
+            getReturnType() {
                 return parser.checker.getTypeAtLocation(node.type || node);
             },
-            getDocumentationComment: function () {
-                var symbol = getSymbolFromNode(parser.checker, node);
+            getDocumentationComment() {
+                const symbol = getSymbolFromNode(parser.checker, node);
                 return symbol.getDocumentationComment(parser.checker);
             },
-            getJsDocTags: function () {
-                var symbol = getSymbolFromNode(parser.checker, node);
+            getJsDocTags() {
+                const symbol = getSymbolFromNode(parser.checker, node);
                 return symbol.getJsDocTags();
             },
         };
@@ -1402,8 +1432,8 @@ function generateSignatureFromTypeNode(parser, node) {
     return undefined;
 }
 export function getValueFromSignatureNode(parser, declaration) {
-    var checker = parser.checker;
-    var signature = checker.getSignatureFromDeclaration(declaration) ||
+    const { checker } = parser;
+    const signature = checker.getSignatureFromDeclaration(declaration) ||
         generateSignatureFromTypeNode(parser, declaration);
     if (signature) {
         return getValueFromSignature(parser, declaration, signature);
@@ -1411,13 +1441,13 @@ export function getValueFromSignatureNode(parser, declaration) {
     return unknownValue(safeGetText(checker, declaration));
 }
 function getObjectValueFromType(parser, type) {
-    var properties = type
+    const properties = type
         .getProperties()
-        .map(function (symbol) {
+        .map(symbol => {
         return getValueFromNode(parser, getValueDeclaration(symbol));
     })
         .filter(filterObjectProperties);
-    var callSignatures = type.getCallSignatures().map(function (s) {
+    const callSignatures = type.getCallSignatures().map(s => {
         return getValueFromSignatureNode(parser, s.getDeclaration());
     });
     if (callSignatures.length) {
@@ -1427,17 +1457,16 @@ function getObjectValueFromType(parser, type) {
         }
         return callSignatures[0];
     }
-    return { kind: 'object', properties: properties };
+    return { kind: 'object', properties };
 }
 /**
  * Get defaults from JSDoc tags if available and do some simple processing to extract useful type
  * information. JSDoc tags are not type checked, so our processing is limited.
  */
 export function getDefaultFromTags(tags) {
-    for (var _i = 0, tags_1 = tags; _i < tags_1.length; _i++) {
-        var tag = tags_1[_i];
+    for (const tag of tags) {
         if (tag.name === 'default') {
-            var text = (tag.text || '').replace('{', '').replace('}', '');
+            const text = (tag.text || '').replace('{', '').replace('}', '');
             if ([
                 'string',
                 'number',
@@ -1486,8 +1515,7 @@ export function createParserPlugin(fn) {
  * new parser per file. Instead use the parser directly and call `parser.getExportedSymbols` for
  * each file to share memory.
  */
-export function parse(program, fileName, plugins) {
-    if (plugins === void 0) { plugins = []; }
-    var parser = new DocParser(program, plugins);
+export function parse(program, fileName, plugins = []) {
+    const parser = new DocParser(program, plugins);
     return parser.getExportedSymbols(fileName);
 }