@angular/compiler

  • Version 13.3.6
  • Published
  • 8.82 MB
  • 1 dependency
  • MIT license

Install

npm i @angular/compiler
yarn add @angular/compiler
pnpm add @angular/compiler

Overview

Angular - the compiler library

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable CUSTOM_ELEMENTS_SCHEMA

const CUSTOM_ELEMENTS_SCHEMA: SchemaMetadata;

    variable DEFAULT_INTERPOLATION_CONFIG

    const DEFAULT_INTERPOLATION_CONFIG: InterpolationConfig;

      variable DYNAMIC_TYPE

      const DYNAMIC_TYPE: BuiltinType;

        variable emitDistinctChangesOnlyDefaultValue

        const emitDistinctChangesOnlyDefaultValue: boolean;
        • Copyright Google LLC 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

        variable EOF

        const EOF: Token;

          variable NO_ERRORS_SCHEMA

          const NO_ERRORS_SCHEMA: SchemaMetadata;

            variable NONE_TYPE

            const NONE_TYPE: BuiltinType;

              variable STRING_TYPE

              const STRING_TYPE: BuiltinType;

                variable VERSION

                const VERSION: Version;

                  Functions

                  function compileClassMetadata

                  compileClassMetadata: (metadata: R3ClassMetadata) => o.Expression;

                    function compileComponentFromMetadata

                    compileComponentFromMetadata: (
                    meta: R3ComponentMetadata,
                    constantPool: ConstantPool,
                    bindingParser: BindingParser
                    ) => R3CompiledExpression;
                    • Compile a component for the render3 runtime as defined by the R3ComponentMetadata.

                    function compileDeclareClassMetadata

                    compileDeclareClassMetadata: (metadata: R3ClassMetadata) => o.Expression;

                      function compileDeclareComponentFromMetadata

                      compileDeclareComponentFromMetadata: (
                      meta: R3ComponentMetadata,
                      template: ParsedTemplate,
                      additionalTemplateInfo: DeclareComponentTemplateInfo
                      ) => R3CompiledExpression;
                      • Compile a component declaration defined by the R3ComponentMetadata.

                      function compileDeclareDirectiveFromMetadata

                      compileDeclareDirectiveFromMetadata: (
                      meta: R3DirectiveMetadata
                      ) => R3CompiledExpression;
                      • Compile a directive declaration defined by the R3DirectiveMetadata.

                      function compileDeclareFactoryFunction

                      compileDeclareFactoryFunction: (meta: R3FactoryMetadata) => R3CompiledExpression;

                        function compileDeclareInjectableFromMetadata

                        compileDeclareInjectableFromMetadata: (
                        meta: R3InjectableMetadata
                        ) => R3CompiledExpression;
                        • Compile a Injectable declaration defined by the R3InjectableMetadata.

                        function compileDeclareInjectorFromMetadata

                        compileDeclareInjectorFromMetadata: (
                        meta: R3InjectorMetadata
                        ) => R3CompiledExpression;

                          function compileDeclareNgModuleFromMetadata

                          compileDeclareNgModuleFromMetadata: (
                          meta: R3NgModuleMetadata
                          ) => R3CompiledExpression;

                            function compileDeclarePipeFromMetadata

                            compileDeclarePipeFromMetadata: (meta: R3PipeMetadata) => R3CompiledExpression;
                            • Compile a Pipe declaration defined by the R3PipeMetadata.

                            function compileDirectiveFromMetadata

                            compileDirectiveFromMetadata: (
                            meta: R3DirectiveMetadata,
                            constantPool: ConstantPool,
                            bindingParser: BindingParser
                            ) => R3CompiledExpression;
                            • Compile a directive for the render3 runtime as defined by the R3DirectiveMetadata.

                            function compileFactoryFunction

                            compileFactoryFunction: (meta: R3FactoryMetadata) => R3CompiledExpression;
                            • Construct a factory function expression for the given R3FactoryMetadata.

                            function compileInjectable

                            compileInjectable: (
                            meta: R3InjectableMetadata,
                            resolveForwardRefs: boolean
                            ) => R3CompiledExpression;

                              function compileInjector

                              compileInjector: (meta: R3InjectorMetadata) => R3CompiledExpression;

                                function compileNgModule

                                compileNgModule: (meta: R3NgModuleMetadata) => R3CompiledExpression;
                                • Construct an R3NgModuleDef for the given R3NgModuleMetadata.

                                function compilePipeFromMetadata

                                compilePipeFromMetadata: (metadata: R3PipeMetadata) => R3CompiledExpression;

                                  function computeMsgId

                                  computeMsgId: (msg: string, meaning?: string) => string;

                                    function createInjectableType

                                    createInjectableType: (meta: R3InjectableMetadata) => o.ExpressionType;

                                      function createMayBeForwardRefExpression

                                      createMayBeForwardRefExpression: <T extends o.Expression>(
                                      expression: T,
                                      forwardRef: ForwardRefHandling
                                      ) => MaybeForwardRefExpression<T>;

                                        function devOnlyGuardedExpression

                                        devOnlyGuardedExpression: (expr: o.Expression) => o.Expression;

                                          function getHtmlTagDefinition

                                          getHtmlTagDefinition: (tagName: string) => HtmlTagDefinition;

                                            function getNsPrefix

                                            getNsPrefix: { (fullName: string): string; (fullName: null): null };

                                              function getSafePropertyAccessString

                                              getSafePropertyAccessString: (accessor: string, name: string) => string;

                                                function identifierName

                                                identifierName: (
                                                compileIdentifier: CompileIdentifierMetadata | null | undefined
                                                ) => string | null;

                                                  function isIdentifier

                                                  isIdentifier: (input: string) => boolean;

                                                    function isNgContainer

                                                    isNgContainer: (tagName: string) => boolean;

                                                      function isNgContent

                                                      isNgContent: (tagName: string) => boolean;

                                                        function isNgTemplate

                                                        isNgTemplate: (tagName: string) => boolean;

                                                          function jsDocComment

                                                          jsDocComment: (tags?: JSDocTag[]) => JSDocComment;

                                                            function leadingComment

                                                            leadingComment: (
                                                            text: string,
                                                            multiline?: boolean,
                                                            trailingNewline?: boolean
                                                            ) => LeadingComment;

                                                              function literalMap

                                                              literalMap: (
                                                              values: { key: string; quoted: boolean; value: Expression }[],
                                                              type?: MapType | null
                                                              ) => LiteralMapExpr;

                                                                function makeBindingParser

                                                                makeBindingParser: (interpolationConfig?: InterpolationConfig) => BindingParser;
                                                                • Construct a BindingParser with a default configuration.

                                                                function mergeNsAndName

                                                                mergeNsAndName: (prefix: string, localName: string) => string;

                                                                  function parseHostBindings

                                                                  parseHostBindings: (host: {
                                                                  [key: string]: string | o.Expression;
                                                                  }) => ParsedHostBindings;

                                                                    function parseTemplate

                                                                    parseTemplate: (
                                                                    template: string,
                                                                    templateUrl: string,
                                                                    options?: ParseTemplateOptions
                                                                    ) => ParsedTemplate;
                                                                    • Parse a template into render3 Nodes and additional metadata, with no other dependencies.

                                                                      Parameter template

                                                                      text of the template to parse

                                                                      Parameter templateUrl

                                                                      URL to use for source mapping of the parsed template

                                                                      Parameter options

                                                                      options to modify how the template is parsed

                                                                    function preserveWhitespacesDefault

                                                                    preserveWhitespacesDefault: (
                                                                    preserveWhitespacesOption: boolean | null,
                                                                    defaultSetting?: boolean
                                                                    ) => boolean;

                                                                      function publishFacade

                                                                      publishFacade: (global: any) => void;

                                                                        function r3JitTypeSourceSpan

                                                                        r3JitTypeSourceSpan: (
                                                                        kind: string,
                                                                        typeName: string,
                                                                        sourceUrl: string
                                                                        ) => ParseSourceSpan;
                                                                        • Generates Source Span object for a given R3 Type for JIT mode.

                                                                          Parameter kind

                                                                          Component or Directive.

                                                                          Parameter typeName

                                                                          name of the Component or Directive.

                                                                          Parameter sourceUrl

                                                                          reference to Component or Directive source.

                                                                          Returns

                                                                          instance of ParseSourceSpan that represent a given Component or Directive.

                                                                        function sanitizeIdentifier

                                                                        sanitizeIdentifier: (name: string) => string;

                                                                          function splitNsName

                                                                          splitNsName: (elementName: string) => [string | null, string];

                                                                            function verifyHostBindings

                                                                            verifyHostBindings: (
                                                                            bindings: ParsedHostBindings,
                                                                            sourceSpan: ParseSourceSpan
                                                                            ) => ParseError[];
                                                                            • Verifies host bindings and returns the list of errors (if any). Empty array indicates that a given set of host bindings has no errors.

                                                                              Parameter bindings

                                                                              set of host bindings to verify.

                                                                              Parameter sourceSpan

                                                                              source span where host bindings were defined.

                                                                              Returns

                                                                              array of errors associated with a given set of host bindings.

                                                                            function visitAll

                                                                            visitAll: (visitor: Visitor, nodes: Node[], context?: any) => any[];

                                                                              Classes

                                                                              class AbsoluteSourceSpan

                                                                              class AbsoluteSourceSpan {}
                                                                              • Records the absolute position of a text span in a source file, where start and end are the starting and ending byte offsets, respectively, of the text span in a source file.

                                                                              constructor

                                                                              constructor(start: number, end: number);

                                                                                property end

                                                                                readonly end: number;

                                                                                  property start

                                                                                  readonly start: number;

                                                                                    class ArrayType

                                                                                    class ArrayType extends Type {}

                                                                                      constructor

                                                                                      constructor(of: Type, modifiers?: TypeModifier);

                                                                                        property of

                                                                                        of: Type;

                                                                                          method visitType

                                                                                          visitType: (visitor: TypeVisitor, context: any) => any;

                                                                                            class AST

                                                                                            abstract class AST {}

                                                                                              constructor

                                                                                              constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan);

                                                                                                property sourceSpan

                                                                                                sourceSpan: AbsoluteSourceSpan;
                                                                                                • Absolute location of the expression AST in a source code file.

                                                                                                property span

                                                                                                span: ParseSpan;

                                                                                                  method toString

                                                                                                  toString: () => string;

                                                                                                    method visit

                                                                                                    abstract visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                      class AstMemoryEfficientTransformer

                                                                                                      class AstMemoryEfficientTransformer implements AstVisitor {}

                                                                                                        method visitAll

                                                                                                        visitAll: (asts: any[]) => any[];

                                                                                                          method visitBinary

                                                                                                          visitBinary: (ast: Binary, context: any) => AST;

                                                                                                            method visitCall

                                                                                                            visitCall: (ast: Call, context: any) => AST;

                                                                                                              method visitChain

                                                                                                              visitChain: (ast: Chain, context: any) => AST;

                                                                                                                method visitConditional

                                                                                                                visitConditional: (ast: Conditional, context: any) => AST;

                                                                                                                  method visitImplicitReceiver

                                                                                                                  visitImplicitReceiver: (ast: ImplicitReceiver, context: any) => AST;

                                                                                                                    method visitInterpolation

                                                                                                                    visitInterpolation: (ast: Interpolation, context: any) => Interpolation;

                                                                                                                      method visitKeyedRead

                                                                                                                      visitKeyedRead: (ast: KeyedRead, context: any) => AST;

                                                                                                                        method visitKeyedWrite

                                                                                                                        visitKeyedWrite: (ast: KeyedWrite, context: any) => AST;

                                                                                                                          method visitLiteralArray

                                                                                                                          visitLiteralArray: (ast: LiteralArray, context: any) => AST;

                                                                                                                            method visitLiteralMap

                                                                                                                            visitLiteralMap: (ast: LiteralMap, context: any) => AST;

                                                                                                                              method visitLiteralPrimitive

                                                                                                                              visitLiteralPrimitive: (ast: LiteralPrimitive, context: any) => AST;

                                                                                                                                method visitNonNullAssert

                                                                                                                                visitNonNullAssert: (ast: NonNullAssert, context: any) => AST;

                                                                                                                                  method visitPipe

                                                                                                                                  visitPipe: (ast: BindingPipe, context: any) => AST;

                                                                                                                                    method visitPrefixNot

                                                                                                                                    visitPrefixNot: (ast: PrefixNot, context: any) => AST;

                                                                                                                                      method visitPropertyRead

                                                                                                                                      visitPropertyRead: (ast: PropertyRead, context: any) => AST;

                                                                                                                                        method visitPropertyWrite

                                                                                                                                        visitPropertyWrite: (ast: PropertyWrite, context: any) => AST;

                                                                                                                                          method visitQuote

                                                                                                                                          visitQuote: (ast: Quote, context: any) => AST;

                                                                                                                                            method visitSafeCall

                                                                                                                                            visitSafeCall: (ast: SafeCall, context: any) => AST;

                                                                                                                                              method visitSafeKeyedRead

                                                                                                                                              visitSafeKeyedRead: (ast: SafeKeyedRead, context: any) => AST;

                                                                                                                                                method visitSafePropertyRead

                                                                                                                                                visitSafePropertyRead: (ast: SafePropertyRead, context: any) => AST;

                                                                                                                                                  method visitThisReceiver

                                                                                                                                                  visitThisReceiver: (ast: ThisReceiver, context: any) => AST;

                                                                                                                                                    method visitUnary

                                                                                                                                                    visitUnary: (ast: Unary, context: any) => AST;

                                                                                                                                                      class AstTransformer

                                                                                                                                                      class AstTransformer implements AstVisitor {}

                                                                                                                                                        method visitAll

                                                                                                                                                        visitAll: (asts: any[]) => any[];

                                                                                                                                                          method visitBinary

                                                                                                                                                          visitBinary: (ast: Binary, context: any) => AST;

                                                                                                                                                            method visitCall

                                                                                                                                                            visitCall: (ast: Call, context: any) => AST;

                                                                                                                                                              method visitChain

                                                                                                                                                              visitChain: (ast: Chain, context: any) => AST;

                                                                                                                                                                method visitConditional

                                                                                                                                                                visitConditional: (ast: Conditional, context: any) => AST;

                                                                                                                                                                  method visitImplicitReceiver

                                                                                                                                                                  visitImplicitReceiver: (ast: ImplicitReceiver, context: any) => AST;

                                                                                                                                                                    method visitInterpolation

                                                                                                                                                                    visitInterpolation: (ast: Interpolation, context: any) => AST;

                                                                                                                                                                      method visitKeyedRead

                                                                                                                                                                      visitKeyedRead: (ast: KeyedRead, context: any) => AST;

                                                                                                                                                                        method visitKeyedWrite

                                                                                                                                                                        visitKeyedWrite: (ast: KeyedWrite, context: any) => AST;

                                                                                                                                                                          method visitLiteralArray

                                                                                                                                                                          visitLiteralArray: (ast: LiteralArray, context: any) => AST;

                                                                                                                                                                            method visitLiteralMap

                                                                                                                                                                            visitLiteralMap: (ast: LiteralMap, context: any) => AST;

                                                                                                                                                                              method visitLiteralPrimitive

                                                                                                                                                                              visitLiteralPrimitive: (ast: LiteralPrimitive, context: any) => AST;

                                                                                                                                                                                method visitNonNullAssert

                                                                                                                                                                                visitNonNullAssert: (ast: NonNullAssert, context: any) => AST;

                                                                                                                                                                                  method visitPipe

                                                                                                                                                                                  visitPipe: (ast: BindingPipe, context: any) => AST;

                                                                                                                                                                                    method visitPrefixNot

                                                                                                                                                                                    visitPrefixNot: (ast: PrefixNot, context: any) => AST;

                                                                                                                                                                                      method visitPropertyRead

                                                                                                                                                                                      visitPropertyRead: (ast: PropertyRead, context: any) => AST;

                                                                                                                                                                                        method visitPropertyWrite

                                                                                                                                                                                        visitPropertyWrite: (ast: PropertyWrite, context: any) => AST;

                                                                                                                                                                                          method visitQuote

                                                                                                                                                                                          visitQuote: (ast: Quote, context: any) => AST;

                                                                                                                                                                                            method visitSafeCall

                                                                                                                                                                                            visitSafeCall: (ast: SafeCall, context: any) => AST;

                                                                                                                                                                                              method visitSafeKeyedRead

                                                                                                                                                                                              visitSafeKeyedRead: (ast: SafeKeyedRead, context: any) => AST;

                                                                                                                                                                                                method visitSafePropertyRead

                                                                                                                                                                                                visitSafePropertyRead: (ast: SafePropertyRead, context: any) => AST;

                                                                                                                                                                                                  method visitThisReceiver

                                                                                                                                                                                                  visitThisReceiver: (ast: ThisReceiver, context: any) => AST;

                                                                                                                                                                                                    method visitUnary

                                                                                                                                                                                                    visitUnary: (ast: Unary, context: any) => AST;

                                                                                                                                                                                                      class ASTWithName

                                                                                                                                                                                                      abstract class ASTWithName extends AST {}

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                        span: ParseSpan,
                                                                                                                                                                                                        sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                        nameSpan: AbsoluteSourceSpan
                                                                                                                                                                                                        );

                                                                                                                                                                                                          property nameSpan

                                                                                                                                                                                                          nameSpan: AbsoluteSourceSpan;

                                                                                                                                                                                                            class ASTWithSource

                                                                                                                                                                                                            class ASTWithSource extends AST {}

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                              ast: AST,
                                                                                                                                                                                                              source: string,
                                                                                                                                                                                                              location: string,
                                                                                                                                                                                                              absoluteOffset: number,
                                                                                                                                                                                                              errors: ParserError[]
                                                                                                                                                                                                              );

                                                                                                                                                                                                                property ast

                                                                                                                                                                                                                ast: AST;

                                                                                                                                                                                                                  property errors

                                                                                                                                                                                                                  errors: ParserError[];

                                                                                                                                                                                                                    property location

                                                                                                                                                                                                                    location: string;

                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                      source: string;

                                                                                                                                                                                                                        method toString

                                                                                                                                                                                                                        toString: () => string;

                                                                                                                                                                                                                          method visit

                                                                                                                                                                                                                          visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                            class Attribute

                                                                                                                                                                                                                            class Attribute extends NodeWithI18n {}

                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                              value: string,
                                                                                                                                                                                                                              sourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                              keySpan: ParseSourceSpan,
                                                                                                                                                                                                                              valueSpan: ParseSourceSpan,
                                                                                                                                                                                                                              valueTokens: InterpolatedAttributeToken[],
                                                                                                                                                                                                                              i18n: I18nMeta
                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                property keySpan

                                                                                                                                                                                                                                readonly keySpan: ParseSourceSpan;

                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                      property valueSpan

                                                                                                                                                                                                                                      valueSpan: ParseSourceSpan;

                                                                                                                                                                                                                                        property valueTokens

                                                                                                                                                                                                                                        valueTokens: InterpolatedAttributeToken[];

                                                                                                                                                                                                                                          method visit

                                                                                                                                                                                                                                          visit: (visitor: Visitor, context: any) => any;

                                                                                                                                                                                                                                            class Binary

                                                                                                                                                                                                                                            class Binary extends AST {}

                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                              span: ParseSpan,
                                                                                                                                                                                                                                              sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                                                              operation: string,
                                                                                                                                                                                                                                              left: AST,
                                                                                                                                                                                                                                              right: AST
                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                property left

                                                                                                                                                                                                                                                left: AST;

                                                                                                                                                                                                                                                  property operation

                                                                                                                                                                                                                                                  operation: string;

                                                                                                                                                                                                                                                    property right

                                                                                                                                                                                                                                                    right: AST;

                                                                                                                                                                                                                                                      method visit

                                                                                                                                                                                                                                                      visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                        class BinaryOperatorExpr

                                                                                                                                                                                                                                                        class BinaryOperatorExpr extends Expression {}

                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                          operator: BinaryOperator,
                                                                                                                                                                                                                                                          lhs: Expression,
                                                                                                                                                                                                                                                          rhs: Expression,
                                                                                                                                                                                                                                                          type?: Type,
                                                                                                                                                                                                                                                          sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                          parens?: boolean
                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                            property lhs

                                                                                                                                                                                                                                                            lhs: Expression;

                                                                                                                                                                                                                                                              property operator

                                                                                                                                                                                                                                                              operator: BinaryOperator;

                                                                                                                                                                                                                                                                property parens

                                                                                                                                                                                                                                                                parens: boolean;

                                                                                                                                                                                                                                                                  property rhs

                                                                                                                                                                                                                                                                  rhs: Expression;

                                                                                                                                                                                                                                                                    method isConstant

                                                                                                                                                                                                                                                                    isConstant: () => boolean;

                                                                                                                                                                                                                                                                      method isEquivalent

                                                                                                                                                                                                                                                                      isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                        method visitExpression

                                                                                                                                                                                                                                                                        visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                          class BindingPipe

                                                                                                                                                                                                                                                                          class BindingPipe extends ASTWithName {}

                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                            span: ParseSpan,
                                                                                                                                                                                                                                                                            sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                                                                                            exp: AST,
                                                                                                                                                                                                                                                                            name: string,
                                                                                                                                                                                                                                                                            args: any[],
                                                                                                                                                                                                                                                                            nameSpan: AbsoluteSourceSpan
                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                              property args

                                                                                                                                                                                                                                                                              args: any[];

                                                                                                                                                                                                                                                                                property exp

                                                                                                                                                                                                                                                                                exp: AST;

                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                    method visit

                                                                                                                                                                                                                                                                                    visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                                                      class BoundElementProperty

                                                                                                                                                                                                                                                                                      class BoundElementProperty {}

                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                        name: string,
                                                                                                                                                                                                                                                                                        type: BindingType,
                                                                                                                                                                                                                                                                                        securityContext: SecurityContext,
                                                                                                                                                                                                                                                                                        value: ASTWithSource,
                                                                                                                                                                                                                                                                                        unit: string,
                                                                                                                                                                                                                                                                                        sourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                        keySpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                        valueSpan: ParseSourceSpan
                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                          property keySpan

                                                                                                                                                                                                                                                                                          readonly keySpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                              property securityContext

                                                                                                                                                                                                                                                                                              securityContext: SecurityContext;

                                                                                                                                                                                                                                                                                                property sourceSpan

                                                                                                                                                                                                                                                                                                sourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                  type: BindingType;

                                                                                                                                                                                                                                                                                                    property unit

                                                                                                                                                                                                                                                                                                    unit: string;

                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                      value: ASTWithSource;

                                                                                                                                                                                                                                                                                                        property valueSpan

                                                                                                                                                                                                                                                                                                        valueSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                          class BuiltinType

                                                                                                                                                                                                                                                                                                          class BuiltinType extends Type {}

                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                            constructor(name: BuiltinTypeName, modifiers?: TypeModifier);

                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                              name: BuiltinTypeName;

                                                                                                                                                                                                                                                                                                                method visitType

                                                                                                                                                                                                                                                                                                                visitType: (visitor: TypeVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                  class Call

                                                                                                                                                                                                                                                                                                                  class Call extends AST {}

                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                    span: ParseSpan,
                                                                                                                                                                                                                                                                                                                    sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                                                                                                                                    receiver: AST,
                                                                                                                                                                                                                                                                                                                    args: AST[],
                                                                                                                                                                                                                                                                                                                    argumentSpan: AbsoluteSourceSpan
                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                      property args

                                                                                                                                                                                                                                                                                                                      args: AST[];

                                                                                                                                                                                                                                                                                                                        property argumentSpan

                                                                                                                                                                                                                                                                                                                        argumentSpan: AbsoluteSourceSpan;

                                                                                                                                                                                                                                                                                                                          property receiver

                                                                                                                                                                                                                                                                                                                          receiver: AST;

                                                                                                                                                                                                                                                                                                                            method visit

                                                                                                                                                                                                                                                                                                                            visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                                                                                              class Chain

                                                                                                                                                                                                                                                                                                                              class Chain extends AST {}
                                                                                                                                                                                                                                                                                                                              • Multiple expressions separated by a semicolon.

                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                              constructor(span: ParseSpan, sourceSpan: AbsoluteSourceSpan, expressions: any[]);

                                                                                                                                                                                                                                                                                                                                property expressions

                                                                                                                                                                                                                                                                                                                                expressions: any[];

                                                                                                                                                                                                                                                                                                                                  method visit

                                                                                                                                                                                                                                                                                                                                  visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                                                                                                    class CommaExpr

                                                                                                                                                                                                                                                                                                                                    class CommaExpr extends Expression {}

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(parts: Expression[], sourceSpan?: ParseSourceSpan);

                                                                                                                                                                                                                                                                                                                                        property parts

                                                                                                                                                                                                                                                                                                                                        parts: Expression[];

                                                                                                                                                                                                                                                                                                                                          method isConstant

                                                                                                                                                                                                                                                                                                                                          isConstant: () => boolean;

                                                                                                                                                                                                                                                                                                                                            method isEquivalent

                                                                                                                                                                                                                                                                                                                                            isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                                                                                              method visitExpression

                                                                                                                                                                                                                                                                                                                                              visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                class Comment

                                                                                                                                                                                                                                                                                                                                                class Comment implements BaseNode {}

                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                  constructor(value: string, sourceSpan: ParseSourceSpan);

                                                                                                                                                                                                                                                                                                                                                    property sourceSpan

                                                                                                                                                                                                                                                                                                                                                    sourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                                                                        method visit

                                                                                                                                                                                                                                                                                                                                                        visit: (visitor: Visitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                          class CompilerConfig

                                                                                                                                                                                                                                                                                                                                                          class CompilerConfig {}

                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                            constructor({
                                                                                                                                                                                                                                                                                                                                                            defaultEncapsulation,
                                                                                                                                                                                                                                                                                                                                                            useJit,
                                                                                                                                                                                                                                                                                                                                                            jitDevMode,
                                                                                                                                                                                                                                                                                                                                                            missingTranslation,
                                                                                                                                                                                                                                                                                                                                                            preserveWhitespaces,
                                                                                                                                                                                                                                                                                                                                                            strictInjectionParameters,
                                                                                                                                                                                                                                                                                                                                                            }?: {
                                                                                                                                                                                                                                                                                                                                                            defaultEncapsulation?: ViewEncapsulation;
                                                                                                                                                                                                                                                                                                                                                            useJit?: boolean;
                                                                                                                                                                                                                                                                                                                                                            jitDevMode?: boolean;
                                                                                                                                                                                                                                                                                                                                                            missingTranslation?: MissingTranslationStrategy | null;
                                                                                                                                                                                                                                                                                                                                                            preserveWhitespaces?: boolean;
                                                                                                                                                                                                                                                                                                                                                            strictInjectionParameters?: boolean;
                                                                                                                                                                                                                                                                                                                                                            });

                                                                                                                                                                                                                                                                                                                                                              property defaultEncapsulation

                                                                                                                                                                                                                                                                                                                                                              defaultEncapsulation: ViewEncapsulation;

                                                                                                                                                                                                                                                                                                                                                                property jitDevMode

                                                                                                                                                                                                                                                                                                                                                                jitDevMode: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property missingTranslation

                                                                                                                                                                                                                                                                                                                                                                  missingTranslation: MissingTranslationStrategy;

                                                                                                                                                                                                                                                                                                                                                                    property preserveWhitespaces

                                                                                                                                                                                                                                                                                                                                                                    preserveWhitespaces: boolean;

                                                                                                                                                                                                                                                                                                                                                                      property strictInjectionParameters

                                                                                                                                                                                                                                                                                                                                                                      strictInjectionParameters: boolean;

                                                                                                                                                                                                                                                                                                                                                                        property useJit

                                                                                                                                                                                                                                                                                                                                                                        useJit: boolean;

                                                                                                                                                                                                                                                                                                                                                                          class Conditional

                                                                                                                                                                                                                                                                                                                                                                          class Conditional extends AST {}

                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                            span: ParseSpan,
                                                                                                                                                                                                                                                                                                                                                                            sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                            condition: AST,
                                                                                                                                                                                                                                                                                                                                                                            trueExp: AST,
                                                                                                                                                                                                                                                                                                                                                                            falseExp: AST
                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                              property condition

                                                                                                                                                                                                                                                                                                                                                                              condition: AST;

                                                                                                                                                                                                                                                                                                                                                                                property falseExp

                                                                                                                                                                                                                                                                                                                                                                                falseExp: AST;

                                                                                                                                                                                                                                                                                                                                                                                  property trueExp

                                                                                                                                                                                                                                                                                                                                                                                  trueExp: AST;

                                                                                                                                                                                                                                                                                                                                                                                    method visit

                                                                                                                                                                                                                                                                                                                                                                                    visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                      class ConditionalExpr

                                                                                                                                                                                                                                                                                                                                                                                      class ConditionalExpr extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                        condition: Expression,
                                                                                                                                                                                                                                                                                                                                                                                        trueCase: Expression,
                                                                                                                                                                                                                                                                                                                                                                                        falseCase?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                        type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                        sourceSpan?: ParseSourceSpan
                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                          property condition

                                                                                                                                                                                                                                                                                                                                                                                          condition: Expression;

                                                                                                                                                                                                                                                                                                                                                                                            property falseCase

                                                                                                                                                                                                                                                                                                                                                                                            falseCase: Expression;

                                                                                                                                                                                                                                                                                                                                                                                              property trueCase

                                                                                                                                                                                                                                                                                                                                                                                              trueCase: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                method isConstant

                                                                                                                                                                                                                                                                                                                                                                                                isConstant: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                  method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                  isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                    method visitExpression

                                                                                                                                                                                                                                                                                                                                                                                                    visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                      class ConstantPool

                                                                                                                                                                                                                                                                                                                                                                                                      class ConstantPool {}
                                                                                                                                                                                                                                                                                                                                                                                                      • A constant pool allows a code emitter to share constant in an output context.

                                                                                                                                                                                                                                                                                                                                                                                                        The constant pool also supports sharing access to ivy definitions references.

                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                      constructor(isClosureCompilerEnabled?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                        property statements

                                                                                                                                                                                                                                                                                                                                                                                                        statements: o.Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                          method getConstLiteral

                                                                                                                                                                                                                                                                                                                                                                                                          getConstLiteral: (literal: o.Expression, forceShared?: boolean) => o.Expression;

                                                                                                                                                                                                                                                                                                                                                                                                            method getLiteralFactory

                                                                                                                                                                                                                                                                                                                                                                                                            getLiteralFactory: (literal: o.LiteralArrayExpr | o.LiteralMapExpr) => {
                                                                                                                                                                                                                                                                                                                                                                                                            literalFactory: o.Expression;
                                                                                                                                                                                                                                                                                                                                                                                                            literalFactoryArguments: o.Expression[];
                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                              method uniqueName

                                                                                                                                                                                                                                                                                                                                                                                                              uniqueName: (prefix: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                              • Produce a unique name.

                                                                                                                                                                                                                                                                                                                                                                                                                The name might be unique among different prefixes if any of the prefixes end in a digit so the prefix should be a constant string (not based on user input) and must not end in a digit.

                                                                                                                                                                                                                                                                                                                                                                                                              class CssSelector

                                                                                                                                                                                                                                                                                                                                                                                                              class CssSelector {}
                                                                                                                                                                                                                                                                                                                                                                                                              • A css selector contains an element name, css classes and attribute/value pairs with the purpose of selecting subsets out of them.

                                                                                                                                                                                                                                                                                                                                                                                                              property attrs

                                                                                                                                                                                                                                                                                                                                                                                                              attrs: string[];
                                                                                                                                                                                                                                                                                                                                                                                                              • The selectors are encoded in pairs where: - even locations are attribute names - odd locations are attribute values.

                                                                                                                                                                                                                                                                                                                                                                                                                Example: Selector: [key1=value1][key2] would parse to:

                                                                                                                                                                                                                                                                                                                                                                                                                ['key1', 'value1', 'key2', '']

                                                                                                                                                                                                                                                                                                                                                                                                              property classNames

                                                                                                                                                                                                                                                                                                                                                                                                              classNames: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                property element

                                                                                                                                                                                                                                                                                                                                                                                                                element: string;

                                                                                                                                                                                                                                                                                                                                                                                                                  property notSelectors

                                                                                                                                                                                                                                                                                                                                                                                                                  notSelectors: CssSelector[];

                                                                                                                                                                                                                                                                                                                                                                                                                    method addAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                    addAttribute: (name: string, value?: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      method addClassName

                                                                                                                                                                                                                                                                                                                                                                                                                      addClassName: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        method escapeAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                        escapeAttribute: (attr: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                        • Escape $ sequences from the CSS attribute selector.

                                                                                                                                                                                                                                                                                                                                                                                                                          This is needed because $ can have a special meaning in CSS selectors, with this method we are escaping $ with `$'. [MDN web link for more info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).

                                                                                                                                                                                                                                                                                                                                                                                                                          Parameter attr

                                                                                                                                                                                                                                                                                                                                                                                                                          the attribute to escape.

                                                                                                                                                                                                                                                                                                                                                                                                                          Returns

                                                                                                                                                                                                                                                                                                                                                                                                                          the escaped string.

                                                                                                                                                                                                                                                                                                                                                                                                                        method getAttrs

                                                                                                                                                                                                                                                                                                                                                                                                                        getAttrs: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                          method getMatchingElementTemplate

                                                                                                                                                                                                                                                                                                                                                                                                                          getMatchingElementTemplate: () => string;
                                                                                                                                                                                                                                                                                                                                                                                                                          • Gets a template string for an element that matches the selector.

                                                                                                                                                                                                                                                                                                                                                                                                                          method hasElementSelector

                                                                                                                                                                                                                                                                                                                                                                                                                          hasElementSelector: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            method isElementSelector

                                                                                                                                                                                                                                                                                                                                                                                                                            isElementSelector: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                              method parse

                                                                                                                                                                                                                                                                                                                                                                                                                              static parse: (selector: string) => CssSelector[];

                                                                                                                                                                                                                                                                                                                                                                                                                                method setElement

                                                                                                                                                                                                                                                                                                                                                                                                                                setElement: (element?: string | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                  toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method unescapeAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                    unescapeAttribute: (attr: string) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Unescape \$ sequences from the CSS attribute selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                      This is needed because $ can have a special meaning in CSS selectors, but we might want to match an attribute that contains $. [MDN web link for more info](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors).

                                                                                                                                                                                                                                                                                                                                                                                                                                      Parameter attr

                                                                                                                                                                                                                                                                                                                                                                                                                                      the attribute to unescape.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                      the unescaped string.

                                                                                                                                                                                                                                                                                                                                                                                                                                    class DeclareFunctionStmt

                                                                                                                                                                                                                                                                                                                                                                                                                                    class DeclareFunctionStmt extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                      params: FnParam[],
                                                                                                                                                                                                                                                                                                                                                                                                                                      statements: Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                                                                      modifiers?: StmtModifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                      leadingComments?: LeadingComment[]
                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property params

                                                                                                                                                                                                                                                                                                                                                                                                                                          params: FnParam[];

                                                                                                                                                                                                                                                                                                                                                                                                                                            property statements

                                                                                                                                                                                                                                                                                                                                                                                                                                            statements: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                              type: Type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                isEquivalent: (stmt: Statement) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                  visitStatement: (visitor: StatementVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class DeclareVarStmt

                                                                                                                                                                                                                                                                                                                                                                                                                                                    class DeclareVarStmt extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      value?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      modifiers?: StmtModifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      leadingComments?: LeadingComment[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: Type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                            value?: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEquivalent: (stmt: Statement) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                visitStatement: (visitor: StatementVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class DomElementSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class DomElementSchemaRegistry extends ElementSchemaRegistry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method allKnownAttributesOfElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allKnownAttributesOfElement: (tagName: string) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method allKnownElementNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allKnownElementNames: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method allKnownEventsOfElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allKnownEventsOfElement: (tagName: string) => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getDefaultComponentElementName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getDefaultComponentElementName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getMappedPropName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getMappedPropName: (propName: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method hasElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hasElement: (tagName: string, schemaMetas: SchemaMetadata[]) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method hasProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hasProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  propName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  schemaMetas: SchemaMetadata[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method normalizeAnimationStyleProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    normalizeAnimationStyleProperty: (propName: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method normalizeAnimationStyleValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      normalizeAnimationStyleValue: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      camelCaseProp: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      userProvidedProp: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      val: string | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => { error: string; value: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method securityContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        securityContext: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        propName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isAttribute: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => SecurityContext;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • securityContext returns the security context for the given property on the given DOM tag.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tag and property name are statically known and cannot change at runtime, i.e. it is not possible to bind a value into a changing attribute or tag name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          The filtering is based on a list of allowed tags|attributes. All attributes in the schema above are assumed to have the 'NONE' security context, i.e. that they are safe inert string values. Only specific well known attack vectors are assigned their appropriate context.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method validateAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        validateAttribute: (name: string) => { error: boolean; msg?: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method validateProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          validateProperty: (name: string) => { error: boolean; msg?: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Element extends NodeWithI18n {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              attrs: Attribute[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              children: Node[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              startSourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endSourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              i18n?: I18nMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property attrs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                attrs: Attribute[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  children: Node[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property endSourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    endSourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property startSourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        startSourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          visit: (visitor: Visitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ElementSchemaRegistry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract class ElementSchemaRegistry {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method allKnownElementNames

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract allKnownElementNames: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getDefaultComponentElementName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract getDefaultComponentElementName: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getMappedPropName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract getMappedPropName: (propName: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method hasElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract hasElement: (tagName: string, schemaMetas: SchemaMetadata[]) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method hasProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract hasProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tagName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      propName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      schemaMetas: SchemaMetadata[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method normalizeAnimationStyleProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract normalizeAnimationStyleProperty: (propName: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method normalizeAnimationStyleValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract normalizeAnimationStyleValue: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          camelCaseProp: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          userProvidedProp: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          val: string | number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => { error: string; value: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method securityContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract securityContext: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            elementName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            propName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isAttribute: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => SecurityContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method validateAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract validateAttribute: (name: string) => { error: boolean; msg?: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method validateProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract validateProperty: (name: string) => { error: boolean; msg?: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class EmitterVisitorContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class EmitterVisitorContext {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(_indent: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method createRoot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static createRoot: () => EmitterVisitorContext;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method decIndent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        decIndent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method incIndent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          incIndent: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method lineIsEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            lineIsEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method lineLength

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lineLength: () => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method print

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                print: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                from: { sourceSpan: ParseSourceSpan | null } | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                part: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                newLine?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method println

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  println: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from?: { sourceSpan: ParseSourceSpan | null } | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  lastPart?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method removeEmptyLastLine

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    removeEmptyLastLine: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method spanOf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      spanOf: (line: number, column: number) => ParseSourceSpan | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toSource

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toSource: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toSourceMapGenerator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSourceMapGenerator: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          genFilePath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          startsAtLine?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => SourceMapGenerator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class EmptyExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class EmptyExpr extends AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              visit: (visitor: AstVisitor, context?: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Expansion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Expansion extends NodeWithI18n {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  switchValue: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cases: ExpansionCase[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  switchValueSourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  i18n?: I18nMeta
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property cases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    cases: ExpansionCase[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property switchValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      switchValue: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property switchValueSourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        switchValueSourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visit: (visitor: Visitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ExpansionCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ExpansionCase implements BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expression: Node[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                valueSourceSpan: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expSourceSpan: ParseSourceSpan
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expression: Node[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property expSourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expSourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property valueSourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          valueSourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visit: (visitor: Visitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract class Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(type: Type, sourceSpan?: ParseSourceSpan);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property sourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan: ParseSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: Type;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method and

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      and: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method bigger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bigger: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method biggerEquals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          biggerEquals: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method bitwiseAnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bitwiseAnd: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceSpan?: ParseSourceSpan | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parens?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method callFn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              callFn: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              params: Expression[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceSpan?: ParseSourceSpan | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pure?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => InvokeFunctionExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method conditional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                conditional: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                trueCase: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                falseCase?: Expression | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ConditionalExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method divide

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  divide: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    equals: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method identical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      identical: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method instantiate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        instantiate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        params: Expression[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type?: Type | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => InstantiateExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isBlank

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBlank: (sourceSpan?: ParseSourceSpan | null) => Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isConstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract isConstant: () => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Return true if the expression is constant.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract isEquivalent: (e: Expression) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Calculates whether this expression produces the same value as the given expression. Note: We don't check Types nor ParseSourceSpans nor function arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            key: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type?: Type | null,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => ReadKeyExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method lower

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lower: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method lowerEquals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lowerEquals: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method minus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minus: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method modulo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    modulo: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method multiply

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      multiply: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method notEquals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        notEquals: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method notIdentical

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          notIdentical: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method nullishCoalesce

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            nullishCoalesce: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method or

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              or: (rhs: Expression, sourceSpan?: ParseSourceSpan | null) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method plus

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                plus: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                rhs: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceSpan?: ParseSourceSpan | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => BinaryOperatorExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method prop

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  prop: (name: string, sourceSpan?: ParseSourceSpan | null) => ReadPropExpr;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toStmt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toStmt: () => Statement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method visitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ExpressionBinding

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ExpressionBinding {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          key: TemplateBindingIdentifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: ASTWithSource
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          );
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Parameter sourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            entire span of the binding.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            binding name, like ngForOf, ngForTrackBy, ngIf, along with its span. Note that the length of the span may not be the same as key.source.length. For example, 1. key.source = ngFor, key.span is for "ngFor" 2. key.source = ngForOf, key.span is for "of" 3. key.source = ngForTrackBy, key.span is for "trackBy"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Parameter value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            optional expression for the RHS.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly key: TemplateBindingIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property sourceSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly sourceSpan: AbsoluteSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly value: ASTWithSource;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ExpressionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ExpressionStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expr: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  leadingComments?: LeadingComment[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property expr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expr: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isEquivalent: (stmt: Statement) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visitStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        visitStatement: (visitor: StatementVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ExpressionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ExpressionType extends Type {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(value: Expression, modifiers?: TypeModifier, typeParams?: Type[]);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property typeParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeParams: Type[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method visitType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  visitType: (visitor: TypeVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ExternalExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ExternalExpr extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: ExternalReference,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      typeParams?: Type[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceSpan?: ParseSourceSpan
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property typeParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        typeParams: Type[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: ExternalReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isConstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isConstant: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ExternalReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ExternalReference {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(moduleName: string, name: string, runtime?: any);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property moduleName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      moduleName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property runtime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          runtime?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class FunctionExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class FunctionExpr extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              params: FnParam[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              statements: Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  params: FnParam[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property statements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    statements: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isConstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isConstant: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toDeclStmt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toDeclStmt: (name: string, modifiers?: StmtModifier) => DeclareFunctionStmt;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class HtmlParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class HtmlParser extends Parser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor();

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  parse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  url: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: TokenizeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => ParseTreeResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HtmlTagDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HtmlTagDefinition implements TagDefinition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      closedByChildren,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      implicitNamespacePrefix,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contentType,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      closedByParent,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isVoid,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreFirstLf,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preventNamespaceInheritance,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      closedByChildren?: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      closedByParent?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      implicitNamespacePrefix?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      contentType?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | TagContentType
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | { [namespace: string]: TagContentType; default: TagContentType };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isVoid?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreFirstLf?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      preventNamespaceInheritance?: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property canSelfClose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        canSelfClose: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property closedByParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          closedByParent: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property ignoreFirstLf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ignoreFirstLf: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property implicitNamespacePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              implicitNamespacePrefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isVoid

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isVoid: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property preventNamespaceInheritance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  preventNamespaceInheritance: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getContentType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getContentType: (prefix?: string) => TagContentType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method isClosedByChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isClosedByChild: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class I18NHtmlParser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class I18NHtmlParser implements HtmlParser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          _htmlParser: HtmlParser,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          translations?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          translationsFormat?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          missingTranslation?: MissingTranslationStrategy,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          console?: Console
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property getTagDefinition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getTagDefinition: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parse: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              source: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: TokenizeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ParseTreeResult;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class IfStmt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class IfStmt extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  condition: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  trueCase: Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  falseCase?: Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  leadingComments?: LeadingComment[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property condition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    condition: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property falseCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      falseCase: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property trueCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        trueCase: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEquivalent: (stmt: Statement) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visitStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visitStatement: (visitor: StatementVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ImplicitReceiver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ImplicitReceiver extends AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class InstantiateExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class InstantiateExpr extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    classExpr: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: Expression[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceSpan?: ParseSourceSpan
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property classExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        classExpr: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isConstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isConstant: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method visitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Interpolation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Interpolation extends AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  span: ParseSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceSpan: AbsoluteSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  strings: any[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  expressions: any[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    expressions: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property strings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      strings: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        visit: (visitor: AstVisitor, context?: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class InterpolationConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class InterpolationConfig {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Copyright Google LLC 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(start: string, end: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            end: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              start: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method fromArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static fromArray: (markers: [string, string] | null) => InterpolationConfig;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class InvokeFunctionExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class InvokeFunctionExpr extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    fn: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    args: Expression[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type?: Type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceSpan?: ParseSourceSpan,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    pure?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      args: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fn: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pure

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          pure: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isConstant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isConstant: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method isEquivalent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isEquivalent: (e: Expression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                visitExpression: (visitor: ExpressionVisitor, context: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JitEvaluator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JitEvaluator {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • A helper class to manage the evaluation of JIT generated code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method evaluateCode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  evaluateCode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceUrl: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ctx: EmitterVisitorContext,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  vars: { [key: string]: any },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  createSourceMap: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Evaluate a piece of JIT generated code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter sourceUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The URL of this generated code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter ctx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A context object that contains an AST of the code to be evaluated.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter vars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    A map containing the names and values of variables that the evaluated code might reference.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Parameter createSourceMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    If true then create a source-map for the generated code and include it inline as a source-map comment.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    The result of evaluating the code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method evaluateStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  evaluateStatements: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceUrl: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  statements: o.Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  refResolver: ExternalReferenceResolver,