• Version 4.4.6
  • Published
  • 1 dependency
  • MIT license


npm i @angular/tsc-wrapped
yarn add @angular/tsc-wrapped
pnpm add @angular/tsc-wrapped


Wraps the tsc CLI, allowing extensions.






Type Aliases


variable VERSION

const VERSION: number;
  • Copyright Google Inc. All Rights Reserved.

    Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license


function createBundleIndexHost

createBundleIndexHost: (
ngOptions: NgOptions,
rootFiles: string[],
host: ts.CompilerHost
) => { host: ts.CompilerHost; indexName?: string; errors?: ts.Diagnostic[] };

    function isClassMetadata

    isClassMetadata: (value: any) => value is ClassMetadata;

      function isConstructorMetadata

      isConstructorMetadata: (value: any) => value is ConstructorMetadata;

        function isFunctionMetadata

        isFunctionMetadata: (value: any) => value is FunctionMetadata;

          function isInterfaceMetadata

          isInterfaceMetadata: (value: any) => value is InterfaceMetadata;

            function isMemberMetadata

            isMemberMetadata: (value: any) => value is MemberMetadata;

              function isMetadataError

              isMetadataError: (value: any) => value is MetadataError;

                function isMetadataGlobalReferenceExpression

                isMetadataGlobalReferenceExpression: (
                value: any
                ) => value is MetadataGlobalReferenceExpression;

                  function isMetadataImportDefaultReference

                  isMetadataImportDefaultReference: (
                  value: any
                  ) => value is MetadataImportedDefaultReferenceExpression;

                    function isMetadataImportedSymbolReferenceExpression

                    isMetadataImportedSymbolReferenceExpression: (
                    value: any
                    ) => value is MetadataImportedSymbolReferenceExpression;

                      function isMetadataModuleReferenceExpression

                      isMetadataModuleReferenceExpression: (
                      value: any
                      ) => value is MetadataModuleReferenceExpression;

                        function isMetadataSymbolicBinaryExpression

                        isMetadataSymbolicBinaryExpression: (
                        value: any
                        ) => value is MetadataSymbolicBinaryExpression;

                          function isMetadataSymbolicCallExpression

                          isMetadataSymbolicCallExpression: (
                          value: any
                          ) => value is MetadataSymbolicCallExpression;

                            function isMetadataSymbolicExpression

                            isMetadataSymbolicExpression: (
                            value: any
                            ) => value is MetadataSymbolicExpression;

                              function isMetadataSymbolicIfExpression

                              isMetadataSymbolicIfExpression: (
                              value: any
                              ) => value is MetadataSymbolicIfExpression;

                                function isMetadataSymbolicIndexExpression

                                isMetadataSymbolicIndexExpression: (
                                value: any
                                ) => value is MetadataSymbolicIndexExpression;

                                  function isMetadataSymbolicPrefixExpression

                                  isMetadataSymbolicPrefixExpression: (
                                  value: any
                                  ) => value is MetadataSymbolicPrefixExpression;

                                    function isMetadataSymbolicReferenceExpression

                                    isMetadataSymbolicReferenceExpression: (
                                    value: any
                                    ) => value is MetadataSymbolicReferenceExpression;

                                      function isMetadataSymbolicSelectExpression

                                      isMetadataSymbolicSelectExpression: (
                                      value: any
                                      ) => value is MetadataSymbolicSelectExpression;

                                        function isMetadataSymbolicSpreadExpression

                                        isMetadataSymbolicSpreadExpression: (
                                        value: any
                                        ) => value is MetadataSymbolicSpreadExpression;

                                          function isMethodMetadata

                                          isMethodMetadata: (value: any) => value is MethodMetadata;

                                            function isModuleMetadata

                                            isModuleMetadata: (value: any) => value is ModuleMetadata;

                                              function main

                                              main: (
                                              project: string | VinylFile,
                                              cliOptions: CliOptions,
                                              codegen?: CodegenExtension,
                                              options?: ts.CompilerOptions
                                              ) => Promise<any>;

                                                function privateEntriesToIndex

                                                privateEntriesToIndex: (index: string, privates: BundlePrivateEntry[]) => string;


                                                  class CliOptions

                                                  class CliOptions {}
                                                  • Copyright Google Inc. All Rights Reserved.

                                                    Use of this source code is governed by an MIT-style license that can be found in the LICENSE file at https://angular.io/license


                                                  constructor({ basePath }: { basePath?: string });

                                                    property basePath

                                                    basePath: string;

                                                      class CollectorOptions

                                                      class CollectorOptions {}
                                                      • A set of collector options to use when collecting metadata.

                                                      property quotedNames

                                                      quotedNames?: boolean;
                                                      • Collect a hidden field "$quoted$" in objects literals that record when the key was quoted in the source.

                                                      property verboseInvalidExpression

                                                      verboseInvalidExpression?: boolean;
                                                      • Do not simplify invalid expressions.

                                                      property version

                                                      version?: number;
                                                      • Version of the metadata to collect.

                                                      class CompilerHostAdapter

                                                      class CompilerHostAdapter implements MetadataBundlerHost {}


                                                        constructor(host: ts.CompilerHost);

                                                          method getMetadataFor

                                                          getMetadataFor: (fileName: string) => ModuleMetadata;

                                                            class I18nExtractionCliOptions

                                                            class I18nExtractionCliOptions extends CliOptions {}


                                                              }: {
                                                              i18nFormat?: string;
                                                              locale?: string;
                                                              outFile?: string;

                                                                property i18nFormat

                                                                i18nFormat: string;

                                                                  property locale

                                                                  locale: string;

                                                                    property outFile

                                                                    outFile: string;

                                                                      class MetadataBundler

                                                                      class MetadataBundler {}


                                                                        constructor(root: string, importAs: string, host: MetadataBundlerHost);

                                                                          method getMetadataBundle

                                                                          getMetadataBundle: () => BundledModule;

                                                                            method resolveModule

                                                                            static resolveModule: (importName: string, from: string) => string;

                                                                              class MetadataCollector

                                                                              class MetadataCollector {}
                                                                              • Collect decorator metadata from a TypeScript module.


                                                                              constructor(options?: CollectorOptions);

                                                                                method getMetadata

                                                                                getMetadata: (sourceFile: ts.SourceFile, strict?: boolean) => ModuleMetadata;
                                                                                • Returns a JSON.stringify friendly form describing the decorators of the exported classes from the source file that is expected to correspond to a module.

                                                                                class MetadataWriterHost

                                                                                class MetadataWriterHost extends DelegatingHost {}


                                                                                  delegate: ts.CompilerHost,
                                                                                  ngOptions: NgOptions,
                                                                                  emitAllFiles: boolean

                                                                                    property writeFile

                                                                                    writeFile: ts.WriteFileCallback;

                                                                                      class NgcCliOptions

                                                                                      class NgcCliOptions extends CliOptions {}


                                                                                        }: {
                                                                                        i18nFormat?: string;
                                                                                        i18nFile?: string;
                                                                                        locale?: string;
                                                                                        missingTranslation?: string;
                                                                                        basePath?: string;

                                                                                          property i18nFile

                                                                                          i18nFile: string;

                                                                                            property i18nFormat

                                                                                            i18nFormat: string;

                                                                                              property locale

                                                                                              locale: string;

                                                                                                property missingTranslation

                                                                                                missingTranslation: string;

                                                                                                  class UserError

                                                                                                  class UserError extends Error {}


                                                                                                    constructor(message: string);

                                                                                                      property message

                                                                                                      message: string;

                                                                                                        property name

                                                                                                        name: string;

                                                                                                          property stack

                                                                                                          stack: any;

                                                                                                            method toString

                                                                                                            toString: () => string;


                                                                                                              interface AngularCompilerOptions

                                                                                                              interface Options extends ts.CompilerOptions {}

                                                                                                                property alwaysCompileGeneratedCode

                                                                                                                alwaysCompileGeneratedCode?: boolean;

                                                                                                                  property annotateForClosureCompiler

                                                                                                                  annotateForClosureCompiler?: boolean;

                                                                                                                    property annotationsAs

                                                                                                                    annotationsAs?: 'decorators' | 'static fields';

                                                                                                                      property basePath

                                                                                                                      basePath?: string;

                                                                                                                        property debug

                                                                                                                        debug?: boolean;
                                                                                                                        • Deprecated

                                                                                                                          since v4 this option has no effect anymore.

                                                                                                                        property enableLegacyTemplate

                                                                                                                        enableLegacyTemplate?: boolean;

                                                                                                                          property enableSummariesForJit

                                                                                                                          enableSummariesForJit?: boolean;

                                                                                                                            property flatModuleId

                                                                                                                            flatModuleId?: string;

                                                                                                                              property flatModuleOutFile

                                                                                                                              flatModuleOutFile?: string;

                                                                                                                                property genDir

                                                                                                                                genDir?: string;

                                                                                                                                  property generateCodeForLibraries

                                                                                                                                  generateCodeForLibraries?: boolean;

                                                                                                                                    property preserveWhitespaces

                                                                                                                                    preserveWhitespaces?: boolean;

                                                                                                                                      property skipMetadataEmit

                                                                                                                                      skipMetadataEmit?: boolean;

                                                                                                                                        property skipTemplateCodegen

                                                                                                                                        skipTemplateCodegen?: boolean;

                                                                                                                                          property strictMetadataEmit

                                                                                                                                          strictMetadataEmit?: boolean;

                                                                                                                                            property trace

                                                                                                                                            trace?: boolean;

                                                                                                                                              interface BundledModule

                                                                                                                                              interface BundledModule {}

                                                                                                                                                property metadata

                                                                                                                                                metadata: ModuleMetadata;

                                                                                                                                                  property privates

                                                                                                                                                  privates: BundlePrivateEntry[];

                                                                                                                                                    interface BundleEntries

                                                                                                                                                    interface BundleEntries {}

                                                                                                                                                      index signature

                                                                                                                                                      [name: string]: MetadataEntry;

                                                                                                                                                        interface BundlePrivateEntry

                                                                                                                                                        interface BundlePrivateEntry {}

                                                                                                                                                          property module

                                                                                                                                                          module: string;

                                                                                                                                                            property name

                                                                                                                                                            name: string;

                                                                                                                                                              property privateName

                                                                                                                                                              privateName: string;

                                                                                                                                                                interface ClassMetadata

                                                                                                                                                                interface ClassMetadata {}

                                                                                                                                                                  property arity

                                                                                                                                                                  arity?: number;

                                                                                                                                                                    property decorators

                                                                                                                                                                    decorators?: (MetadataSymbolicExpression | MetadataError)[];

                                                                                                                                                                      property extends

                                                                                                                                                                      extends?: MetadataSymbolicExpression | MetadataError;

                                                                                                                                                                        property members

                                                                                                                                                                        members?: MetadataMap;

                                                                                                                                                                          property statics

                                                                                                                                                                          statics?: {
                                                                                                                                                                          [name: string]: MetadataValue | FunctionMetadata;

                                                                                                                                                                            interface CodegenExtension

                                                                                                                                                                            interface CodegenExtension {}

                                                                                                                                                                              call signature

                                                                                                                                                                              ngOptions: NgOptions,
                                                                                                                                                                              cliOptions: CliOptions,
                                                                                                                                                                              program: ts.Program,
                                                                                                                                                                              host: ts.CompilerHost
                                                                                                                                                                              ): Promise<string[]>;
                                                                                                                                                                              • Returns the generated file names.

                                                                                                                                                                              interface ConstructorMetadata

                                                                                                                                                                              interface ConstructorMetadata extends MethodMetadata {}

                                                                                                                                                                                property parameters

                                                                                                                                                                                parameters?: (MetadataSymbolicExpression | MetadataError | null)[];

                                                                                                                                                                                  interface FunctionMetadata

                                                                                                                                                                                  interface FunctionMetadata {}

                                                                                                                                                                                    property defaults

                                                                                                                                                                                    defaults?: MetadataValue[];

                                                                                                                                                                                      property parameters

                                                                                                                                                                                      parameters: string[];

                                                                                                                                                                                        property value

                                                                                                                                                                                        value: MetadataValue;

                                                                                                                                                                                          interface InterfaceMetadata

                                                                                                                                                                                          interface InterfaceMetadata {}

                                                                                                                                                                                            interface MemberMetadata

                                                                                                                                                                                            interface MemberMetadata {}

                                                                                                                                                                                              property decorators

                                                                                                                                                                                              decorators?: (MetadataSymbolicExpression | MetadataError)[];

                                                                                                                                                                                                interface MetadataArray

                                                                                                                                                                                                interface MetadataArray {}

                                                                                                                                                                                                  index signature

                                                                                                                                                                                                  [name: number]: MetadataValue;

                                                                                                                                                                                                    interface MetadataBundlerHost

                                                                                                                                                                                                    interface MetadataBundlerHost {}

                                                                                                                                                                                                      method getMetadataFor

                                                                                                                                                                                                      getMetadataFor: (moduleName: string) => ModuleMetadata;

                                                                                                                                                                                                        interface MetadataError

                                                                                                                                                                                                        interface MetadataError {}

                                                                                                                                                                                                          property character

                                                                                                                                                                                                          character?: number;
                                                                                                                                                                                                          • The number of utf8 code-units from the beginning of the file of the error.

                                                                                                                                                                                                          property context

                                                                                                                                                                                                          context?: {
                                                                                                                                                                                                          [name: string]: string;
                                                                                                                                                                                                          • Context information that can be used to generate a more descriptive error message. The content of the context is dependent on the error message.

                                                                                                                                                                                                          property line

                                                                                                                                                                                                          line?: number;
                                                                                                                                                                                                          • The line number of the error in the .ts file the metadata was created for.

                                                                                                                                                                                                          property message

                                                                                                                                                                                                          message: string;
                                                                                                                                                                                                          • This message should be short and relatively discriptive and should be fixed once it is created. If the reader doesn't recognize the message, it will display the message unmodified. If the reader recognizes the error message is it free to use substitute message the is more descriptive and/or localized.

                                                                                                                                                                                                          property module

                                                                                                                                                                                                          module?: string;
                                                                                                                                                                                                          • The module of the error (only used in bundled metadata)

                                                                                                                                                                                                          interface MetadataGlobalReferenceExpression

                                                                                                                                                                                                          interface MetadataGlobalReferenceExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                            property arguments

                                                                                                                                                                                                            arguments?: MetadataValue[];

                                                                                                                                                                                                              property name

                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                interface MetadataImportedDefaultReferenceExpression

                                                                                                                                                                                                                interface MetadataImportedDefaultReferenceExpression
                                                                                                                                                                                                                extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                  property arguments

                                                                                                                                                                                                                  arguments?: MetadataValue[];

                                                                                                                                                                                                                    property default

                                                                                                                                                                                                                    default: boolean;

                                                                                                                                                                                                                      property module

                                                                                                                                                                                                                      module: string;

                                                                                                                                                                                                                        interface MetadataImportedSymbolReferenceExpression

                                                                                                                                                                                                                        interface MetadataImportedSymbolReferenceExpression
                                                                                                                                                                                                                        extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                          property arguments

                                                                                                                                                                                                                          arguments?: MetadataValue[];

                                                                                                                                                                                                                            property module

                                                                                                                                                                                                                            module: string;

                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                interface MetadataMap

                                                                                                                                                                                                                                interface MetadataMap {}

                                                                                                                                                                                                                                  index signature

                                                                                                                                                                                                                                  [name: string]: MemberMetadata[];

                                                                                                                                                                                                                                    interface MetadataModuleReferenceExpression

                                                                                                                                                                                                                                    interface MetadataModuleReferenceExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                      property module

                                                                                                                                                                                                                                      module: string;

                                                                                                                                                                                                                                        interface MetadataObject

                                                                                                                                                                                                                                        interface MetadataObject {}

                                                                                                                                                                                                                                          index signature

                                                                                                                                                                                                                                          [name: string]: MetadataValue;

                                                                                                                                                                                                                                            interface MetadataSymbolicBinaryExpression

                                                                                                                                                                                                                                            interface MetadataSymbolicBinaryExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                              property left

                                                                                                                                                                                                                                              left: MetadataValue;

                                                                                                                                                                                                                                                property operator

                                                                                                                                                                                                                                                | '&&'
                                                                                                                                                                                                                                                | '||'
                                                                                                                                                                                                                                                | '|'
                                                                                                                                                                                                                                                | '^'
                                                                                                                                                                                                                                                | '&'
                                                                                                                                                                                                                                                | '=='
                                                                                                                                                                                                                                                | '!='
                                                                                                                                                                                                                                                | '==='
                                                                                                                                                                                                                                                | '!=='
                                                                                                                                                                                                                                                | '<'
                                                                                                                                                                                                                                                | '>'
                                                                                                                                                                                                                                                | '<='
                                                                                                                                                                                                                                                | '>='
                                                                                                                                                                                                                                                | 'instanceof'
                                                                                                                                                                                                                                                | 'in'
                                                                                                                                                                                                                                                | 'as'
                                                                                                                                                                                                                                                | '<<'
                                                                                                                                                                                                                                                | '>>'
                                                                                                                                                                                                                                                | '>>>'
                                                                                                                                                                                                                                                | '+'
                                                                                                                                                                                                                                                | '-'
                                                                                                                                                                                                                                                | '*'
                                                                                                                                                                                                                                                | '/'
                                                                                                                                                                                                                                                | '%'
                                                                                                                                                                                                                                                | '**';

                                                                                                                                                                                                                                                  property right

                                                                                                                                                                                                                                                  right: MetadataValue;

                                                                                                                                                                                                                                                    interface MetadataSymbolicCallExpression

                                                                                                                                                                                                                                                    interface MetadataSymbolicCallExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                      property arguments

                                                                                                                                                                                                                                                      arguments?: MetadataValue[];

                                                                                                                                                                                                                                                        property expression

                                                                                                                                                                                                                                                        expression: MetadataValue;

                                                                                                                                                                                                                                                          interface MetadataSymbolicExpression

                                                                                                                                                                                                                                                          interface MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                            interface MetadataSymbolicIfExpression

                                                                                                                                                                                                                                                            interface MetadataSymbolicIfExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                              property condition

                                                                                                                                                                                                                                                              condition: MetadataValue;

                                                                                                                                                                                                                                                                property elseExpression

                                                                                                                                                                                                                                                                elseExpression: MetadataValue;

                                                                                                                                                                                                                                                                  property thenExpression

                                                                                                                                                                                                                                                                  thenExpression: MetadataValue;

                                                                                                                                                                                                                                                                    interface MetadataSymbolicIndexExpression

                                                                                                                                                                                                                                                                    interface MetadataSymbolicIndexExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                                      property expression

                                                                                                                                                                                                                                                                      expression: MetadataValue;

                                                                                                                                                                                                                                                                        property index

                                                                                                                                                                                                                                                                        index: MetadataValue;

                                                                                                                                                                                                                                                                          interface MetadataSymbolicPrefixExpression

                                                                                                                                                                                                                                                                          interface MetadataSymbolicPrefixExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                                            property operand

                                                                                                                                                                                                                                                                            operand: MetadataValue;

                                                                                                                                                                                                                                                                              property operator

                                                                                                                                                                                                                                                                              operator: '+' | '-' | '~' | '!';

                                                                                                                                                                                                                                                                                interface MetadataSymbolicSelectExpression

                                                                                                                                                                                                                                                                                interface MetadataSymbolicSelectExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                                                  property expression

                                                                                                                                                                                                                                                                                  expression: MetadataValue;

                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                      interface MetadataSymbolicSpreadExpression

                                                                                                                                                                                                                                                                                      interface MetadataSymbolicSpreadExpression extends MetadataSymbolicExpression {}

                                                                                                                                                                                                                                                                                        property expression

                                                                                                                                                                                                                                                                                        expression: MetadataValue;

                                                                                                                                                                                                                                                                                          interface MethodMetadata

                                                                                                                                                                                                                                                                                          interface MethodMetadata extends MemberMetadata {}

                                                                                                                                                                                                                                                                                            property parameterDecorators

                                                                                                                                                                                                                                                                                            parameterDecorators?: (MetadataSymbolicExpression | MetadataError)[][];

                                                                                                                                                                                                                                                                                              interface ModuleExportMetadata

                                                                                                                                                                                                                                                                                              interface ModuleExportMetadata {}

                                                                                                                                                                                                                                                                                                property export

                                                                                                                                                                                                                                                                                                export?: (
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                name: string;
                                                                                                                                                                                                                                                                                                as: string;

                                                                                                                                                                                                                                                                                                  property from

                                                                                                                                                                                                                                                                                                  from: string;

                                                                                                                                                                                                                                                                                                    interface ModuleMetadata

                                                                                                                                                                                                                                                                                                    interface ModuleMetadata {}

                                                                                                                                                                                                                                                                                                      property exports

                                                                                                                                                                                                                                                                                                      exports?: ModuleExportMetadata[];

                                                                                                                                                                                                                                                                                                        property importAs

                                                                                                                                                                                                                                                                                                        importAs?: string;

                                                                                                                                                                                                                                                                                                          property metadata

                                                                                                                                                                                                                                                                                                          metadata: {
                                                                                                                                                                                                                                                                                                          [name: string]: MetadataEntry;

                                                                                                                                                                                                                                                                                                            property origins

                                                                                                                                                                                                                                                                                                            origins?: {
                                                                                                                                                                                                                                                                                                            [name: string]: string;

                                                                                                                                                                                                                                                                                                              property version

                                                                                                                                                                                                                                                                                                              version: number;

                                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                                type MetadataEntry

                                                                                                                                                                                                                                                                                                                type MetadataEntry =
                                                                                                                                                                                                                                                                                                                | ClassMetadata
                                                                                                                                                                                                                                                                                                                | InterfaceMetadata
                                                                                                                                                                                                                                                                                                                | FunctionMetadata
                                                                                                                                                                                                                                                                                                                | MetadataValue;

                                                                                                                                                                                                                                                                                                                  type MetadataSymbolicReferenceExpression

                                                                                                                                                                                                                                                                                                                  type MetadataSymbolicReferenceExpression =
                                                                                                                                                                                                                                                                                                                  | MetadataGlobalReferenceExpression
                                                                                                                                                                                                                                                                                                                  | MetadataModuleReferenceExpression
                                                                                                                                                                                                                                                                                                                  | MetadataImportedSymbolReferenceExpression
                                                                                                                                                                                                                                                                                                                  | MetadataImportedDefaultReferenceExpression;

                                                                                                                                                                                                                                                                                                                    type MetadataValue

                                                                                                                                                                                                                                                                                                                    type MetadataValue =
                                                                                                                                                                                                                                                                                                                    | string
                                                                                                                                                                                                                                                                                                                    | number
                                                                                                                                                                                                                                                                                                                    | boolean
                                                                                                                                                                                                                                                                                                                    | MetadataObject
                                                                                                                                                                                                                                                                                                                    | MetadataArray
                                                                                                                                                                                                                                                                                                                    | MetadataSymbolicExpression
                                                                                                                                                                                                                                                                                                                    | MetadataError;

                                                                                                                                                                                                                                                                                                                      Package Files (10)

                                                                                                                                                                                                                                                                                                                      Dependencies (1)

                                                                                                                                                                                                                                                                                                                      Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                      No dev dependencies.

                                                                                                                                                                                                                                                                                                                      Peer Dependencies (1)


                                                                                                                                                                                                                                                                                                                      To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                                                                                                                                                                                                      You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@angular/tsc-wrapped.

                                                                                                                                                                                                                                                                                                                      • Markdown
                                                                                                                                                                                                                                                                                                                      • HTML
                                                                                                                                                                                                                                                                                                                        <a href="https://www.jsdocs.io/package/@angular/tsc-wrapped"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>