typedoc 0.23.24 → 0.23.25

package/dist/lib/converter/types.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertType = exports.loadConverters = void 0;
-const assert = require("assert");
-const ts = require("typescript");
+const assert_1 = __importDefault(require("assert"));
+const typescript_1 = __importDefault(require("typescript"));
 const models_1 = require("../models");
 const array_1 = require("../utils/array");
 const converter_events_1 = require("./converter-events");
@@ -51,7 +54,7 @@ function loadConverters() {
                 // Might happen if running on an older TS version.
                 continue;
             }
-            assert(!converters.has(key));
+            (0, assert_1.default)(!converters.has(key));
             converters.set(key, actor);
         }
     }
@@ -79,12 +82,12 @@ function convertType(context, typeOrNode) {
         return requestBugReport(context, typeOrNode);
     }
     // IgnoreErrors is important, without it, we can't assert that we will get a node.
-    const node = context.checker.typeToTypeNode(typeOrNode, void 0, ts.NodeBuilderFlags.IgnoreErrors);
-    assert(node); // According to the TS source of typeToString, this is a bug if it does not hold.
+    const node = context.checker.typeToTypeNode(typeOrNode, void 0, typescript_1.default.NodeBuilderFlags.IgnoreErrors);
+    (0, assert_1.default)(node); // According to the TS source of typeToString, this is a bug if it does not hold.
     const symbol = typeOrNode.getSymbol();
     if (symbol) {
-        if (node.kind !== ts.SyntaxKind.TypeReference &&
-            node.kind !== ts.SyntaxKind.ArrayType &&
+        if (node.kind !== typescript_1.default.SyntaxKind.TypeReference &&
+            node.kind !== typescript_1.default.SyntaxKind.ArrayType &&
             seenTypeSymbols.has(symbol)) {
             const typeString = context.checker.typeToString(typeOrNode);
             context.logger.verbose(`Refusing to recurse when converting type: ${typeString}`);
@@ -108,7 +111,7 @@ function convertType(context, typeOrNode) {
 }
 exports.convertType = convertType;
 const arrayConverter = {
-    kind: [ts.SyntaxKind.ArrayType],
+    kind: [typescript_1.default.SyntaxKind.ArrayType],
     convert(context, node) {
         return new models_1.ArrayType(convertType(context, node.elementType));
     },
@@ -116,12 +119,12 @@ const arrayConverter = {
         const params = context.checker.getTypeArguments(type);
         // This is *almost* always true... except for when this type is in the constraint of a type parameter see GH#1408
         // assert(params.length === 1);
-        assert(params.length > 0);
+        (0, assert_1.default)(params.length > 0);
         return new models_1.ArrayType(convertType(context, params[0]));
     },
 };
 const conditionalConverter = {
-    kind: [ts.SyntaxKind.ConditionalType],
+    kind: [typescript_1.default.SyntaxKind.ConditionalType],
     convert(context, node) {
         return new models_1.ConditionalType(convertType(context, node.checkType), convertType(context, node.extendsType), convertType(context, node.trueType), convertType(context, node.falseType));
     },
@@ -130,7 +133,7 @@ const conditionalConverter = {
     },
 };
 const constructorConverter = {
-    kind: [ts.SyntaxKind.ConstructorType],
+    kind: [typescript_1.default.SyntaxKind.ConstructorType],
     convert(context, node) {
         const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
         const type = context.getTypeAtLocation(node);
@@ -146,7 +149,7 @@ const constructorConverter = {
         // This is unfortunate... but seems the obvious place to put this with the current
         // architecture. Ideally, this would be a property on a "ConstructorType"... but that
         // needs to wait until TypeDoc 0.22 when making other breaking changes.
-        if (node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword)) {
+        if (node.modifiers?.some((m) => m.kind === typescript_1.default.SyntaxKind.AbstractKeyword)) {
             signature.setFlag(models_1.ReflectionFlag.Abstract);
         }
         context.registerReflection(signature, void 0);
@@ -169,7 +172,7 @@ const constructorConverter = {
     },
 };
 const exprWithTypeArgsConverter = {
-    kind: [ts.SyntaxKind.ExpressionWithTypeArguments],
+    kind: [typescript_1.default.SyntaxKind.ExpressionWithTypeArguments],
     convert(context, node) {
         const targetSymbol = context.getSymbolAtLocation(node.expression);
         // Mixins... we might not have a symbol here.
@@ -184,7 +187,7 @@ const exprWithTypeArgsConverter = {
     convertType: requestBugReport,
 };
 const functionTypeConverter = {
-    kind: [ts.SyntaxKind.FunctionType],
+    kind: [typescript_1.default.SyntaxKind.FunctionType],
     convert(context, node) {
         const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
         const type = context.getTypeAtLocation(node);
@@ -216,21 +219,21 @@ const functionTypeConverter = {
     },
 };
 const importType = {
-    kind: [ts.SyntaxKind.ImportType],
+    kind: [typescript_1.default.SyntaxKind.ImportType],
     convert(context, node) {
         const name = node.qualifier?.getText() ?? "__module";
         const symbol = context.checker.getSymbolAtLocation(node);
-        assert(symbol, "Missing symbol when converting import type node");
+        (0, assert_1.default)(symbol, "Missing symbol when converting import type node");
         return models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, name);
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
-        assert(symbol, "Missing symbol when converting import type"); // Should be a compiler error
+        (0, assert_1.default)(symbol, "Missing symbol when converting import type"); // Should be a compiler error
         return models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context, "__module");
     },
 };
 const indexedAccessConverter = {
-    kind: [ts.SyntaxKind.IndexedAccessType],
+    kind: [typescript_1.default.SyntaxKind.IndexedAccessType],
     convert(context, node) {
         return new models_1.IndexedAccessType(convertType(context, node.objectType), convertType(context, node.indexType));
     },
@@ -239,7 +242,7 @@ const indexedAccessConverter = {
     },
 };
 const inferredConverter = {
-    kind: [ts.SyntaxKind.InferType],
+    kind: [typescript_1.default.SyntaxKind.InferType],
     convert(context, node) {
         return new models_1.InferredType(node.typeParameter.name.text, maybeConvertType(context, node.typeParameter.constraint));
     },
@@ -248,7 +251,7 @@ const inferredConverter = {
     },
 };
 const intersectionConverter = {
-    kind: [ts.SyntaxKind.IntersectionType],
+    kind: [typescript_1.default.SyntaxKind.IntersectionType],
     convert(context, node) {
         return new models_1.IntersectionType(node.types.map((type) => convertType(context, type)));
     },
@@ -257,7 +260,7 @@ const intersectionConverter = {
     },
 };
 const jsDocVariadicTypeConverter = {
-    kind: [ts.SyntaxKind.JSDocVariadicType],
+    kind: [typescript_1.default.SyntaxKind.JSDocVariadicType],
     convert(context, node) {
         return new models_1.ArrayType(convertType(context, node.type));
     },
@@ -265,32 +268,32 @@ const jsDocVariadicTypeConverter = {
     convertType: requestBugReport,
 };
 const keywordNames = {
-    [ts.SyntaxKind.AnyKeyword]: "any",
-    [ts.SyntaxKind.BigIntKeyword]: "bigint",
-    [ts.SyntaxKind.BooleanKeyword]: "boolean",
-    [ts.SyntaxKind.NeverKeyword]: "never",
-    [ts.SyntaxKind.NumberKeyword]: "number",
-    [ts.SyntaxKind.ObjectKeyword]: "object",
-    [ts.SyntaxKind.StringKeyword]: "string",
-    [ts.SyntaxKind.SymbolKeyword]: "symbol",
-    [ts.SyntaxKind.UndefinedKeyword]: "undefined",
-    [ts.SyntaxKind.UnknownKeyword]: "unknown",
-    [ts.SyntaxKind.VoidKeyword]: "void",
-    [ts.SyntaxKind.IntrinsicKeyword]: "intrinsic",
+    [typescript_1.default.SyntaxKind.AnyKeyword]: "any",
+    [typescript_1.default.SyntaxKind.BigIntKeyword]: "bigint",
+    [typescript_1.default.SyntaxKind.BooleanKeyword]: "boolean",
+    [typescript_1.default.SyntaxKind.NeverKeyword]: "never",
+    [typescript_1.default.SyntaxKind.NumberKeyword]: "number",
+    [typescript_1.default.SyntaxKind.ObjectKeyword]: "object",
+    [typescript_1.default.SyntaxKind.StringKeyword]: "string",
+    [typescript_1.default.SyntaxKind.SymbolKeyword]: "symbol",
+    [typescript_1.default.SyntaxKind.UndefinedKeyword]: "undefined",
+    [typescript_1.default.SyntaxKind.UnknownKeyword]: "unknown",
+    [typescript_1.default.SyntaxKind.VoidKeyword]: "void",
+    [typescript_1.default.SyntaxKind.IntrinsicKeyword]: "intrinsic",
 };
 const keywordConverter = {
     kind: [
-        ts.SyntaxKind.AnyKeyword,
-        ts.SyntaxKind.BigIntKeyword,
-        ts.SyntaxKind.BooleanKeyword,
-        ts.SyntaxKind.NeverKeyword,
-        ts.SyntaxKind.NumberKeyword,
-        ts.SyntaxKind.ObjectKeyword,
-        ts.SyntaxKind.StringKeyword,
-        ts.SyntaxKind.SymbolKeyword,
-        ts.SyntaxKind.UndefinedKeyword,
-        ts.SyntaxKind.UnknownKeyword,
-        ts.SyntaxKind.VoidKeyword,
+        typescript_1.default.SyntaxKind.AnyKeyword,
+        typescript_1.default.SyntaxKind.BigIntKeyword,
+        typescript_1.default.SyntaxKind.BooleanKeyword,
+        typescript_1.default.SyntaxKind.NeverKeyword,
+        typescript_1.default.SyntaxKind.NumberKeyword,
+        typescript_1.default.SyntaxKind.ObjectKeyword,
+        typescript_1.default.SyntaxKind.StringKeyword,
+        typescript_1.default.SyntaxKind.SymbolKeyword,
+        typescript_1.default.SyntaxKind.UndefinedKeyword,
+        typescript_1.default.SyntaxKind.UnknownKeyword,
+        typescript_1.default.SyntaxKind.VoidKeyword,
     ],
     convert(_context, node) {
         return new models_1.IntrinsicType(keywordNames[node.kind]);
@@ -300,7 +303,7 @@ const keywordConverter = {
     },
 };
 const optionalConverter = {
-    kind: [ts.SyntaxKind.OptionalType],
+    kind: [typescript_1.default.SyntaxKind.OptionalType],
     convert(context, node) {
         return new models_1.OptionalType((0, reflections_1.removeUndefined)(convertType(context, node.type)));
     },
@@ -308,7 +311,7 @@ const optionalConverter = {
     convertType: requestBugReport,
 };
 const parensConverter = {
-    kind: [ts.SyntaxKind.ParenthesizedType],
+    kind: [typescript_1.default.SyntaxKind.ParenthesizedType],
     convert(context, node) {
         return convertType(context, node.type);
     },
@@ -316,9 +319,9 @@ const parensConverter = {
     convertType: requestBugReport,
 };
 const predicateConverter = {
-    kind: [ts.SyntaxKind.TypePredicate],
+    kind: [typescript_1.default.SyntaxKind.TypePredicate],
     convert(context, node) {
-        const name = ts.isThisTypeNode(node.parameterName)
+        const name = typescript_1.default.isThisTypeNode(node.parameterName)
             ? "this"
             : node.parameterName.getText();
         const asserts = !!node.assertsModifier;
@@ -331,7 +334,7 @@ const predicateConverter = {
 // This is a horrible thing... we're going to want to split this into converters
 // for different types at some point.
 const typeLiteralConverter = {
-    kind: [ts.SyntaxKind.TypeLiteral],
+    kind: [typescript_1.default.SyntaxKind.TypeLiteral],
     convert(context, node) {
         const symbol = context.getSymbolAtLocation(node) ?? node.symbol;
         const type = context.getTypeAtLocation(node);
@@ -376,7 +379,7 @@ const typeLiteralConverter = {
     },
 };
 const queryConverter = {
-    kind: [ts.SyntaxKind.TypeQuery],
+    kind: [typescript_1.default.SyntaxKind.TypeQuery],
     convert(context, node) {
         const querySymbol = context.getSymbolAtLocation(node.exprName);
         if (!querySymbol) {
@@ -388,14 +391,14 @@ const queryConverter = {
     },
     convertType(context, type) {
         const symbol = type.getSymbol();
-        assert(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
+        (0, assert_1.default)(symbol, `Query type failed to get a symbol for: ${context.checker.typeToString(type)}. This is a bug.`);
         return new models_1.QueryType(models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context));
     },
 };
 const referenceConverter = {
-    kind: [ts.SyntaxKind.TypeReference],
+    kind: [typescript_1.default.SyntaxKind.TypeReference],
     convert(context, node) {
-        const isArray = context.checker.typeToTypeNode(context.checker.getTypeAtLocation(node.typeName), void 0, ts.NodeBuilderFlags.IgnoreErrors)?.kind === ts.SyntaxKind.ArrayType;
+        const isArray = context.checker.typeToTypeNode(context.checker.getTypeAtLocation(node.typeName), void 0, typescript_1.default.NodeBuilderFlags.IgnoreErrors)?.kind === typescript_1.default.SyntaxKind.ArrayType;
         if (isArray) {
             return new models_1.ArrayType(convertType(context, node.typeArguments?.[0]));
         }
@@ -413,7 +416,7 @@ const referenceConverter = {
             return models_1.ReferenceType.createBrokenReference(context.checker.typeToString(type), context.project);
         }
         const ref = models_1.ReferenceType.createSymbolReference(context.resolveAliasedSymbol(symbol), context);
-        if (type.flags & ts.TypeFlags.StringMapping) {
+        if (type.flags & typescript_1.default.TypeFlags.StringMapping) {
             ref.typeArguments = [
                 convertType(context, type.type),
             ];
@@ -427,7 +430,7 @@ const referenceConverter = {
     },
 };
 const restConverter = {
-    kind: [ts.SyntaxKind.RestType],
+    kind: [typescript_1.default.SyntaxKind.RestType],
     convert(context, node) {
         return new models_1.RestType(convertType(context, node.type));
     },
@@ -435,7 +438,7 @@ const restConverter = {
     convertType: requestBugReport,
 };
 const namedTupleMemberConverter = {
-    kind: [ts.SyntaxKind.NamedTupleMember],
+    kind: [typescript_1.default.SyntaxKind.NamedTupleMember],
     convert(context, node) {
         const innerType = convertType(context, node.type);
         return new models_1.NamedTupleMember(node.name.getText(), !!node.questionToken, innerType);
@@ -450,7 +453,7 @@ const namedTupleMemberConverter = {
 //                          ^ questionToken
 //                              ^^^^^^ type
 const mappedConverter = {
-    kind: [ts.SyntaxKind.MappedType],
+    kind: [typescript_1.default.SyntaxKind.MappedType],
     convert(context, node) {
         const optionalModifier = kindToModifier(node.questionToken?.kind);
         const templateType = convertType(context, node.type);
@@ -468,47 +471,47 @@ const mappedConverter = {
     },
 };
 const literalTypeConverter = {
-    kind: [ts.SyntaxKind.LiteralType],
+    kind: [typescript_1.default.SyntaxKind.LiteralType],
     convert(context, node) {
         switch (node.literal.kind) {
-            case ts.SyntaxKind.TrueKeyword:
-            case ts.SyntaxKind.FalseKeyword:
-                return new models_1.LiteralType(node.literal.kind === ts.SyntaxKind.TrueKeyword);
-            case ts.SyntaxKind.StringLiteral:
+            case typescript_1.default.SyntaxKind.TrueKeyword:
+            case typescript_1.default.SyntaxKind.FalseKeyword:
+                return new models_1.LiteralType(node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword);
+            case typescript_1.default.SyntaxKind.StringLiteral:
                 return new models_1.LiteralType(node.literal.text);
-            case ts.SyntaxKind.NumericLiteral:
+            case typescript_1.default.SyntaxKind.NumericLiteral:
                 return new models_1.LiteralType(Number(node.literal.text));
-            case ts.SyntaxKind.NullKeyword:
+            case typescript_1.default.SyntaxKind.NullKeyword:
                 return new models_1.LiteralType(null);
-            case ts.SyntaxKind.PrefixUnaryExpression: {
+            case typescript_1.default.SyntaxKind.PrefixUnaryExpression: {
                 const operand = node.literal
                     .operand;
                 switch (operand.kind) {
-                    case ts.SyntaxKind.NumericLiteral:
+                    case typescript_1.default.SyntaxKind.NumericLiteral:
                         return new models_1.LiteralType(Number(node.literal.getText()));
-                    case ts.SyntaxKind.BigIntLiteral:
+                    case typescript_1.default.SyntaxKind.BigIntLiteral:
                         return new models_1.LiteralType(BigInt(node.literal.getText().replace("n", "")));
                     default:
                         return requestBugReport(context, node.literal);
                 }
             }
-            case ts.SyntaxKind.BigIntLiteral:
+            case typescript_1.default.SyntaxKind.BigIntLiteral:
                 return new models_1.LiteralType(BigInt(node.literal.getText().replace("n", "")));
-            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+            case typescript_1.default.SyntaxKind.NoSubstitutionTemplateLiteral:
                 return new models_1.LiteralType(node.literal.text);
         }
         return requestBugReport(context, node.literal);
     },
     convertType(_context, type, node) {
         switch (node.literal.kind) {
-            case ts.SyntaxKind.StringLiteral:
+            case typescript_1.default.SyntaxKind.StringLiteral:
                 return new models_1.LiteralType(node.literal.text);
-            case ts.SyntaxKind.NumericLiteral:
+            case typescript_1.default.SyntaxKind.NumericLiteral:
                 return new models_1.LiteralType(+node.literal.text);
-            case ts.SyntaxKind.TrueKeyword:
-            case ts.SyntaxKind.FalseKeyword:
-                return new models_1.LiteralType(node.literal.kind === ts.SyntaxKind.TrueKeyword);
-            case ts.SyntaxKind.NullKeyword:
+            case typescript_1.default.SyntaxKind.TrueKeyword:
+            case typescript_1.default.SyntaxKind.FalseKeyword:
+                return new models_1.LiteralType(node.literal.kind === typescript_1.default.SyntaxKind.TrueKeyword);
+            case typescript_1.default.SyntaxKind.NullKeyword:
                 return new models_1.LiteralType(null);
         }
         if (typeof type.value === "object") {
@@ -518,14 +521,14 @@ const literalTypeConverter = {
     },
 };
 const templateLiteralConverter = {
-    kind: [ts.SyntaxKind.TemplateLiteralType],
+    kind: [typescript_1.default.SyntaxKind.TemplateLiteralType],
     convert(context, node) {
         return new models_1.TemplateLiteralType(node.head.text, node.templateSpans.map((span) => {
             return [convertType(context, span.type), span.literal.text];
         }));
     },
     convertType(context, type) {
-        assert(type.texts.length === type.types.length + 1);
+        (0, assert_1.default)(type.texts.length === type.types.length + 1);
         const parts = [];
         for (const [a, b] of (0, array_1.zip)(type.types, type.texts.slice(1))) {
             parts.push([convertType(context, a), b]);
@@ -534,7 +537,7 @@ const templateLiteralConverter = {
     },
 };
 const thisConverter = {
-    kind: [ts.SyntaxKind.ThisType],
+    kind: [typescript_1.default.SyntaxKind.ThisType],
     convert() {
         return new models_1.IntrinsicType("this");
     },
@@ -543,7 +546,7 @@ const thisConverter = {
     },
 };
 const tupleConverter = {
-    kind: [ts.SyntaxKind.TupleType],
+    kind: [typescript_1.default.SyntaxKind.TupleType],
     convert(context, node) {
         const elements = node.elements.map((node) => convertType(context, node));
         return new models_1.TupleType(elements);
@@ -556,14 +559,14 @@ const tupleConverter = {
             elements = elements?.map((el, i) => new models_1.NamedTupleMember(namedDeclarations[i].name.getText(), !!namedDeclarations[i].questionToken, (0, reflections_1.removeUndefined)(el)));
         }
         elements = elements?.map((el, i) => {
-            if (type.target.elementFlags[i] & ts.ElementFlags.Variable) {
+            if (type.target.elementFlags[i] & typescript_1.default.ElementFlags.Variable) {
                 // In the node case, we don't need to add the wrapping Array type... but we do here.
                 if (el instanceof models_1.NamedTupleMember) {
                     return new models_1.RestType(new models_1.NamedTupleMember(el.name, el.isOptional, new models_1.ArrayType(el.element)));
                 }
                 return new models_1.RestType(new models_1.ArrayType(el));
             }
-            if (type.target.elementFlags[i] & ts.ElementFlags.Optional &&
+            if (type.target.elementFlags[i] & typescript_1.default.ElementFlags.Optional &&
                 !(el instanceof models_1.NamedTupleMember)) {
                 return new models_1.OptionalType((0, reflections_1.removeUndefined)(el));
             }
@@ -573,31 +576,31 @@ const tupleConverter = {
     },
 };
 const supportedOperatorNames = {
-    [ts.SyntaxKind.KeyOfKeyword]: "keyof",
-    [ts.SyntaxKind.UniqueKeyword]: "unique",
-    [ts.SyntaxKind.ReadonlyKeyword]: "readonly",
+    [typescript_1.default.SyntaxKind.KeyOfKeyword]: "keyof",
+    [typescript_1.default.SyntaxKind.UniqueKeyword]: "unique",
+    [typescript_1.default.SyntaxKind.ReadonlyKeyword]: "readonly",
 };
 const typeOperatorConverter = {
-    kind: [ts.SyntaxKind.TypeOperator],
+    kind: [typescript_1.default.SyntaxKind.TypeOperator],
     convert(context, node) {
         return new models_1.TypeOperatorType(convertType(context, node.type), supportedOperatorNames[node.operator]);
     },
     convertType(context, type, node) {
         // readonly is only valid on array and tuple literal types.
-        if (node.operator === ts.SyntaxKind.ReadonlyKeyword) {
+        if (node.operator === typescript_1.default.SyntaxKind.ReadonlyKeyword) {
             const resolved = resolveReference(type);
-            assert((0, nodes_1.isObjectType)(resolved));
+            (0, assert_1.default)((0, nodes_1.isObjectType)(resolved));
             const args = context.checker
                 .getTypeArguments(type)
                 .map((type) => convertType(context, type));
-            const inner = resolved.objectFlags & ts.ObjectFlags.Tuple
+            const inner = resolved.objectFlags & typescript_1.default.ObjectFlags.Tuple
                 ? new models_1.TupleType(args)
                 : new models_1.ArrayType(args[0]);
             return new models_1.TypeOperatorType(inner, "readonly");
         }
         // keyof will only show up with generic functions, otherwise it gets eagerly
         // resolved to a union of strings.
-        if (node.operator === ts.SyntaxKind.KeyOfKeyword) {
+        if (node.operator === typescript_1.default.SyntaxKind.KeyOfKeyword) {
             // TS 4.2 added this to enable better tracking of type aliases.
             if (type.isUnion() && type.origin) {
                 return convertType(context, type.origin);
@@ -612,7 +615,7 @@ const typeOperatorConverter = {
     },
 };
 const unionConverter = {
-    kind: [ts.SyntaxKind.UnionType],
+    kind: [typescript_1.default.SyntaxKind.UnionType],
     convert(context, node) {
         return new models_1.UnionType(node.types.map((type) => convertType(context, type)));
     },
@@ -625,7 +628,7 @@ const unionConverter = {
     },
 };
 const jsDocNullableTypeConverter = {
-    kind: [ts.SyntaxKind.JSDocNullableType],
+    kind: [typescript_1.default.SyntaxKind.JSDocNullableType],
     convert(context, node) {
         return new models_1.UnionType([
             convertType(context, node.type),
@@ -636,7 +639,7 @@ const jsDocNullableTypeConverter = {
     convertType: requestBugReport,
 };
 const jsDocNonNullableTypeConverter = {
-    kind: [ts.SyntaxKind.JSDocNonNullableType],
+    kind: [typescript_1.default.SyntaxKind.JSDocNonNullableType],
     convert(context, node) {
         return convertType(context, node.type);
     },
@@ -645,7 +648,7 @@ const jsDocNonNullableTypeConverter = {
 };
 function requestBugReport(context, nodeOrType) {
     if ("kind" in nodeOrType) {
-        const kindName = ts.SyntaxKind[nodeOrType.kind];
+        const kindName = typescript_1.default.SyntaxKind[nodeOrType.kind];
         context.logger.warn(`Failed to convert type node with kind: ${kindName} and text ${nodeOrType.getText()}. Please report a bug.`, nodeOrType);
         return new models_1.UnknownType(nodeOrType.getText());
     }
@@ -656,18 +659,18 @@ function requestBugReport(context, nodeOrType) {
     }
 }
 function resolveReference(type) {
-    if ((0, nodes_1.isObjectType)(type) && type.objectFlags & ts.ObjectFlags.Reference) {
+    if ((0, nodes_1.isObjectType)(type) && type.objectFlags & typescript_1.default.ObjectFlags.Reference) {
         return type.target;
     }
     return type;
 }
 function kindToModifier(kind) {
     switch (kind) {
-        case ts.SyntaxKind.ReadonlyKeyword:
-        case ts.SyntaxKind.QuestionToken:
-        case ts.SyntaxKind.PlusToken:
+        case typescript_1.default.SyntaxKind.ReadonlyKeyword:
+        case typescript_1.default.SyntaxKind.QuestionToken:
+        case typescript_1.default.SyntaxKind.PlusToken:
             return "+";
-        case ts.SyntaxKind.MinusToken:
+        case typescript_1.default.SyntaxKind.MinusToken:
             return "-";
         default:
             return undefined;

package/dist/lib/converter/utils/base-path.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BasePath = void 0;
-const Path = require("path");
+const Path = __importStar(require("path"));
 /**
  * Helper class that determines the common base path of a set of files.
  *

package/dist/lib/converter/utils/nodes.d.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import ts from "typescript";
 export declare function isNamedNode(node: ts.Node): node is ts.Node & {
     name: ts.Identifier | ts.PrivateIdentifier | ts.ComputedPropertyName;
 };

package/dist/lib/converter/utils/nodes.js

@@ -1,10 +1,13 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isObjectType = exports.getHeritageTypes = exports.isNamedNode = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 function isNamedNode(node) {
     const name = node.name;
-    return !!name && (ts.isMemberName(name) || ts.isComputedPropertyName(name));
+    return !!name && (typescript_1.default.isMemberName(name) || typescript_1.default.isComputedPropertyName(name));
 }
 exports.isNamedNode = isNamedNode;
 function getHeritageTypes(declarations, kind) {

package/dist/lib/converter/utils/symbols.d.ts

@@ -1,2 +1,2 @@
-import * as ts from "typescript";
+import ts from "typescript";
 export declare function resolveAliasedSymbol(symbol: ts.Symbol, checker: ts.TypeChecker): ts.Symbol;

package/dist/lib/converter/utils/symbols.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAliasedSymbol = void 0;
-const ts = require("typescript");
+const typescript_1 = __importDefault(require("typescript"));
 function resolveAliasedSymbol(symbol, checker) {
-    while (ts.SymbolFlags.Alias & symbol.flags) {
+    while (typescript_1.default.SymbolFlags.Alias & symbol.flags) {
         symbol = checker.getAliasedSymbol(symbol);
     }
     return symbol;

package/dist/lib/output/components.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContextAwareRendererComponent = exports.RendererComponent = exports.Component = void 0;
-const Path = require("path");
+const Path = __importStar(require("path"));
 const component_1 = require("../utils/component");
 Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return component_1.Component; } });
 const index_1 = require("../models/reflections/index");

package/dist/lib/output/events.js

@@ -1,7 +1,30 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexEvent = exports.MarkdownEvent = exports.PageEvent = exports.RendererEvent = void 0;
-const Path = require("path");
+const Path = __importStar(require("path"));
 const events_1 = require("../utils/events");
 /**
  * An event emitted by the {@link Renderer} class at the very beginning and