Function serializeAsClass

test/fixtures/snapshot/typescript.js:54765–54825

(symbol, localName, modifierFlags)

                    return undefined;
                }
                function serializeAsClass(symbol, localName, modifierFlags) {
                    var _a, _b;
                    var originalDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isClassLike);
                    var oldEnclosing = context.enclosingDeclaration;
                    context.enclosingDeclaration = originalDecl || oldEnclosing;
                    var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol);
                    var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); });
                    var classType = getDeclaredTypeOfClassOrInterface(symbol);
                    var baseTypes = getBaseTypes(classType);
                    var originalImplements = originalDecl && ts.getEffectiveImplementsTypeNodes(originalDecl);
                    var implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements)
                        || ts.mapDefined(getImplementsTypes(classType), serializeImplementedType);
                    var staticType = getTypeOfSymbol(symbol);
                    var isClass = !!((_b = staticType.symbol) === null || _b === void 0 ? void 0 : _b.valueDeclaration) && ts.isClassLike(staticType.symbol.valueDeclaration);
                    var staticBaseType = isClass
                        ? getBaseConstructorTypeOfClass(staticType)
                        : anyType;
                    var heritageClauses = __spreadArray(__spreadArray([], !ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(94 /* SyntaxKind.ExtendsKeyword */, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], true), !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(117 /* SyntaxKind.ImplementsKeyword */, implementsExpressions)], true);
                    var symbolProps = getNonInterhitedProperties(classType, baseTypes, getPropertiesOfType(classType));
                    var publicSymbolProps = ts.filter(symbolProps, function (s) {
                        // `valueDeclaration` could be undefined if inherited from
                        // a union/intersection base type, but inherited properties
                        // don't matter here.
                        var valueDecl = s.valueDeclaration;
                        return !!valueDecl && !(ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name));
                    });
                    var hasPrivateIdentifier = ts.some(symbolProps, function (s) {
                        // `valueDeclaration` could be undefined if inherited from
                        // a union/intersection base type, but inherited properties
                        // don't matter here.
                        var valueDecl = s.valueDeclaration;
                        return !!valueDecl && ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name);
                    });
                    // Boil down all private properties into a single one.
                    var privateProperties = hasPrivateIdentifier ?
                        [ts.factory.createPropertyDeclaration(
                            /*decorators*/ undefined, 
                            /*modifiers*/ undefined, ts.factory.createPrivateIdentifier("#private"), 
                            /*questionOrExclamationToken*/ undefined, 
                            /*type*/ undefined, 
                            /*initializer*/ undefined)] :
                        ts.emptyArray;
                    var publicProperties = ts.flatMap(publicSymbolProps, function (p) { return serializePropertySymbolForClass(p, /*isStatic*/ false, baseTypes[0]); });
                    // Consider static members empty if symbol also has function or module meaning - function namespacey emit will handle statics
                    var staticMembers = ts.flatMap(ts.filter(getPropertiesOfType(staticType), function (p) { return !(p.flags & 4194304 /* SymbolFlags.Prototype */) && p.escapedName !== "prototype" && !isNamespaceMember(p); }), function (p) { return serializePropertySymbolForClass(p, /*isStatic*/ true, staticBaseType); });
                    // When we encounter an `X.prototype.y` assignment in a JS file, we bind `X` as a class regardless as to whether
                    // the value is ever initialized with a class or function-like value. For cases where `X` could never be
                    // created via `new`, we will inject a `private constructor()` declaration to indicate it is not createable.
                    var isNonConstructableClassLikeInJsFile = !isClass &&
                        !!symbol.valueDeclaration &&
                        ts.isInJSFile(symbol.valueDeclaration) &&
                        !ts.some(getSignaturesOfType(staticType, 1 /* SignatureKind.Construct */));
                    var constructors = isNonConstructableClassLikeInJsFile ?
                        [ts.factory.createConstructorDeclaration(/*decorators*/ undefined, ts.factory.createModifiersFromModifierFlags(8 /* ModifierFlags.Private */), [], /*body*/ undefined)] :
                        serializeSignatures(1 /* SignatureKind.Construct */, staticType, staticBaseType, 171 /* SyntaxKind.Constructor */);
                    var indexSignatures = serializeIndexSignatures(classType, baseTypes[0]);
                    context.enclosingDeclaration = oldEnclosing;
                    addResult(ts.setTextRange(ts.factory.createClassDeclaration(