polymer-analyzer

  • Version 3.2.4
  • Published
  • 1.2 MB
  • 37 dependencies
  • BSD-3-Clause license

Install

npm i polymer-analyzer
yarn add polymer-analyzer
pnpm add polymer-analyzer

Overview

Static analysis for Web Components

Index

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Functions

function applyEdits

applyEdits: (
edits: Edit[],
loader: (url: ResolvedUrl) => Promise<ParsedDocument>
) => Promise<EditResult>;
  • Takes the given edits and, provided there are no overlaps, applies them to the contents loadable from the given loader.

    If there are overlapping edits, then edits earlier in the array get priority over later ones.

function comparePosition

comparePosition: (a: SourcePosition, b: SourcePosition) => number;
  • Returns -1 if source position a comes before source position b, returns 0 if they are the same, returns 1 if a comes after b.

function comparePositionAndRange

comparePositionAndRange: (
position: SourcePosition,
range: SourceRange,
includeEdges?: boolean
) => 1 | -1 | 0;
  • If the position is inside the range, returns 0. If it comes before the range, it returns -1. If it comes after the range, it returns 1.

    TODO(rictic): test this method directly (currently most of its tests are indirectly, through ast-from-source-position).

function correctPosition

correctPosition: (
position: SourcePosition,
locationOffset: LocationOffset
) => SourcePosition;

    function correctSourceRange

    correctSourceRange: {
    (sourceRange: SourceRange, locationOffset?: LocationOffset | null): SourceRange;
    (sourceRange: undefined, locationOffset?: LocationOffset): undefined;
    (sourceRange?: SourceRange, locationOffset?: LocationOffset): SourceRange;
    };
    • Corrects source ranges based on an offset.

      Source ranges for inline documents need to be corrected relative to their positions in their containing documents.

      For example, if a tag appears in the fifth line of its containing document, we need to move all the source ranges inside that script tag down by 5 lines. We also need to correct the column offsets, but only for the first line of the contents.

    function generateAnalysis

    generateAnalysis: (
    input: AnalysisResult,
    urlResolver: UrlResolver,
    filter?: Filter
    ) => Analysis;

      function getAttachedCommentText

      getAttachedCommentText: (node: any) => string | undefined;

        function getLocationOffsetOfStartOfTextContent

        getLocationOffsetOfStartOfTextContent: (
        node: any,
        parsedDocument: ParsedHtmlDocument
        ) => LocationOffset;

          function isPositionInsideRange

          isPositionInsideRange: (
          position: SourcePosition,
          range: SourceRange | undefined,
          includeEdges?: boolean
          ) => boolean;

            function isResolvable

            isResolvable: (x: ScannedFeature & { resolve?: Function }) => x is Resolvable;

              function makeParseLoader

              makeParseLoader: (
              analyzer: Analyzer,
              analysis?: Analysis
              ) => (url: ResolvedUrl) => Promise<ParsedDocument<{} | null | undefined, {}>>;

                function uncorrectPosition

                uncorrectPosition: (
                position: SourcePosition,
                locationOffset: LocationOffset
                ) => SourcePosition;

                  function uncorrectSourceRange

                  uncorrectSourceRange: (
                  sourceRange?: SourceRange,
                  locationOffset?: LocationOffset | null
                  ) => SourceRange | undefined;

                    function validateAnalysis

                    validateAnalysis: (analyzedPackage: Analysis | null | undefined) => void;
                    • Throws if the given object isn't a valid AnalyzedPackage according to the JSON schema.

                    Classes

                    class Analysis

                    class Analysis implements Queryable {}
                    • Represents a queryable interface over all documents in a package/project.

                      Results of queries will include results from all documents in the package, as well as from external dependencies that are transitively imported by documents in the package.

                    constructor

                    constructor(
                    results: Map<ResolvedUrl, Warning | Document<ParsedDocument<{}, {}>>>,
                    context: AnalysisContext
                    );

                      method getDocument

                      getDocument: (
                      packageRelativeUrl: string
                      ) => Result<Document, Warning | undefined>;

                        method getDocumentContaining

                        getDocumentContaining: (
                        sourceRange: SourceRange | undefined
                        ) => Document | undefined;
                        • Potentially narrow down the document that contains the sourceRange. For example, if a source range is inside a inlineDocument, this function will narrow down the document to the most specific inline document.

                          Parameter sourceRange

                          Source range to search for in a document

                        method getFeatures

                        getFeatures: {
                        <K extends keyof FeatureKindMap>(query: QueryWithKind<K>): Set<
                        FeatureKindMap[K]
                        >;
                        (query?: Query): Set<Feature>;
                        };
                        • Get features in the package.

                          Be default this includes features in all documents inside the package, but you can specify whether to also include features that are outside the package reachable by documents inside. See the documentation for Query for more details.

                          You can also narrow by feature kind and identifier.

                        method getWarnings

                        getWarnings: (options?: Query) => Warning[];
                        • Get all warnings in the project.

                        method isExternal

                        static isExternal: (path: string) => boolean;

                          class Analyzer

                          class Analyzer {}
                          • A static analyzer for web projects.

                            An Analyzer can load and parse documents of various types, and extract arbitrary information from the documents, and transitively load dependencies. An Analyzer instance is configured with parsers, and scanners which do the actual work of understanding different file types.

                          constructor

                          constructor(options: Options);

                            property urlResolver

                            readonly urlResolver: UrlResolver;

                              method analyze

                              analyze: (urls: string[], options?: AnalyzeOptions) => Promise<Analysis>;
                              • Loads, parses and analyzes the root document of a dependency graph and its transitive dependencies.

                              method analyzePackage

                              analyzePackage: (options?: AnalyzeOptions) => Promise<Analysis>;

                                method canLoad

                                canLoad: (resolvedUrl: ResolvedUrl) => boolean;
                                • Returns true if the provided resolved URL can be loaded. Obeys the semantics defined by UrlLoader and should only be used to check resolved URLs.

                                method clearCaches

                                clearCaches: () => Promise<void>;
                                • Clear all cached information from this analyzer instance.

                                  Note: if at all possible, instead tell the analyzer about the specific files that changed rather than clearing caches like this. Caching provides large performance gains.

                                method filesChanged

                                filesChanged: (urls: string[]) => Promise<void>;
                                • Clears all information about the given files from our caches, such that future calls to analyze() will reload these files if they're needed.

                                  The analyzer assumes that if this method isn't called with a file's url, then that file has not changed and does not need to be reloaded.

                                  Parameter urls

                                  The urls of files which may have changed.

                                method load

                                load: (resolvedUrl: ResolvedUrl) => Promise<string>;
                                • Loads the content at the provided resolved URL. Obeys the semantics defined by UrlLoader and should only be used to attempt to load resolved URLs.

                                method resolveUrl

                                resolveUrl: (url: string) => ResolvedUrl | undefined;
                                • Resoves url to a new location.

                                class AttributeDatabindingExpression

                                class AttributeDatabindingExpression extends DatabindingExpression {}

                                  constructor

                                  constructor(
                                  astNode: any,
                                  isCompleteBinding: boolean,
                                  direction: '{' | '[',
                                  eventName: string,
                                  attribute: any,
                                  sourceRange: SourceRange,
                                  expressionText: string,
                                  ast: any,
                                  document: ParsedHtmlDocument
                                  );

                                    property astNode

                                    readonly astNode: any;
                                    • The element whose attribute/property is assigned to.

                                    property attribute

                                    readonly attribute: any;
                                    • The attribute we're databinding into.

                                    property databindingInto

                                    readonly databindingInto: string;

                                      property direction

                                      readonly direction: '{' | '[';
                                      • The databinding syntax used.

                                      property eventName

                                      readonly eventName: string;
                                      • If this is a two-way data binding, and an event name was specified (using ::eventName syntax), this is that event name.

                                      property isCompleteBinding

                                      readonly isCompleteBinding: boolean;
                                      • If true, this is databinding into the complete attribute. Polymer treats such databindings specially, e.g. they're setting the property by default, not the attribute.

                                        e.g. foo="{{bar}}" is complete, foo="hello {{bar}} world" is not complete.

                                        An attribute may have multiple incomplete bindings. They will be separate AttributeDatabindingExpressions.

                                      class Class

                                      class Class implements Feature, DeclaredWithStatement {}

                                        constructor

                                        constructor(init: ClassInit, document: Document<ParsedDocument<{}, {}>>);

                                          property abstract

                                          readonly abstract: boolean;

                                            property astNode

                                            readonly astNode: AstNodeWithLanguage;

                                              property className

                                              readonly className: string;
                                              • Deprecated

                                                use the name field instead.

                                              property constructorMethod

                                              constructorMethod?: Method;

                                                property demos

                                                demos: Demo[];

                                                  property description

                                                  description: string;

                                                    property identifiers

                                                    readonly identifiers: Set<string>;

                                                      property jsdoc

                                                      readonly jsdoc: any;

                                                        property kinds

                                                        readonly kinds: Set<string>;

                                                          property methods

                                                          readonly methods: Map<string, Method>;

                                                            property mixins

                                                            readonly mixins: readonly ScannedReference<'element-mixin'>[];
                                                            • Mixins that this class declares with @mixes.

                                                              Mixins are applied linearly after the superclass, in order from first to last. Mixins that compose other mixins will be flattened into a single list. A mixin can be applied more than once, each time its members override those before it in the prototype chain.

                                                            property name

                                                            readonly name: string;

                                                              property privacy

                                                              readonly privacy: Privacy;

                                                                property properties

                                                                readonly properties: Map<string, Property>;

                                                                  property sourceRange

                                                                  readonly sourceRange: SourceRange;

                                                                    property statementAst

                                                                    readonly statementAst: any;

                                                                      property staticMethods

                                                                      readonly staticMethods: Map<string, Method>;

                                                                        property summary

                                                                        readonly summary: string;

                                                                          property superClass

                                                                          readonly superClass: ScannedReference<'class'>;

                                                                            property warnings

                                                                            readonly warnings: Warning[];

                                                                              method emitMetadata

                                                                              emitMetadata: () => object;

                                                                                method emitMethodMetadata

                                                                                emitMethodMetadata: (_method: Method) => object;

                                                                                  method emitPropertyMetadata

                                                                                  emitPropertyMetadata: (_property: Property) => object;

                                                                                    method inheritFrom

                                                                                    protected inheritFrom: (superClass: Class) => void;

                                                                                      class Document

                                                                                      class Document<ParsedType extends ParsedDocument = ParsedDocument>
                                                                                      implements Feature, Queryable {}

                                                                                        constructor

                                                                                        constructor(
                                                                                        base: ScannedDocument,
                                                                                        analyzer: AnalysisContext,
                                                                                        languageAnalysis?: {}
                                                                                        );

                                                                                          property astNode

                                                                                          readonly astNode: AstNodeWithLanguage;

                                                                                            property identifiers

                                                                                            readonly identifiers: ImmutableSet<string>;

                                                                                              property isInline

                                                                                              readonly isInline: boolean;

                                                                                                property kinds

                                                                                                readonly kinds: ImmutableSet<string>;

                                                                                                  property languageAnalysis

                                                                                                  languageAnalysis?: {};

                                                                                                    property parsedDocument

                                                                                                    readonly parsedDocument: ParsedDocument<{}, {}>;

                                                                                                      property resolved

                                                                                                      readonly resolved: boolean;

                                                                                                        property sourceRange

                                                                                                        readonly sourceRange: SourceRange;

                                                                                                          property type

                                                                                                          readonly type: string;

                                                                                                            property url

                                                                                                            readonly url: String & ResolvedUrlBrand;

                                                                                                              property warnings

                                                                                                              warnings: Warning[];

                                                                                                                method getFeatures

                                                                                                                getFeatures: {
                                                                                                                <K extends keyof FeatureKindMap>(query: QueryWithKind<K>): Set<
                                                                                                                FeatureKindMap[K]
                                                                                                                >;
                                                                                                                (query?: Query): Set<Feature>;
                                                                                                                };
                                                                                                                • Get features on the document.

                                                                                                                  Be default it includes only features on the document, but you can specify whether to include features that are reachable by imports, features from outside the current package, etc. See the documentation for Query for more details.

                                                                                                                  You can also narrow by feature kind and identifier.

                                                                                                                method getWarnings

                                                                                                                getWarnings: (query?: Query) => Warning[];
                                                                                                                • Get warnings for the document and all matched features.

                                                                                                                method resolve

                                                                                                                resolve: () => void;
                                                                                                                • Resolves all features of this document, so that they have references to all their dependencies.

                                                                                                                  This method can only be called once

                                                                                                                method stringify

                                                                                                                stringify: () => string;

                                                                                                                  method toString

                                                                                                                  toString: () => string;

                                                                                                                    class DocumentBackreference

                                                                                                                    class DocumentBackreference extends ScannedFeature {}
                                                                                                                    • The DocumentBackreference is added to the set of features for an inline/imported document to provide a link to its containing/importer document.

                                                                                                                    constructor

                                                                                                                    constructor(document: Document<ParsedDocument<{}, {}>>);

                                                                                                                      property document

                                                                                                                      readonly document: Document<ParsedDocument<{}, {}>>;

                                                                                                                        property identifiers

                                                                                                                        identifiers: Set<string>;

                                                                                                                          property kinds

                                                                                                                          kinds: Set<string>;

                                                                                                                            class DomModule

                                                                                                                            class DomModule implements Feature {}

                                                                                                                              constructor

                                                                                                                              constructor(
                                                                                                                              node: any,
                                                                                                                              id: string,
                                                                                                                              comment: string,
                                                                                                                              sourceRange: SourceRange,
                                                                                                                              ast: HtmlAstNode,
                                                                                                                              warnings: Warning[],
                                                                                                                              slots: Slot[],
                                                                                                                              localIds: LocalId[],
                                                                                                                              template: Template,
                                                                                                                              databindings: HtmlDatabindingExpression[]
                                                                                                                              );

                                                                                                                                property 'slots'

                                                                                                                                'slots': Slot[];

                                                                                                                                  property astNode

                                                                                                                                  astNode: HtmlAstNode;

                                                                                                                                    property comment

                                                                                                                                    comment?: string;

                                                                                                                                      property databindings

                                                                                                                                      databindings: HtmlDatabindingExpression[];

                                                                                                                                        property id

                                                                                                                                        id: string;

                                                                                                                                          property identifiers

                                                                                                                                          identifiers: Set<string>;

                                                                                                                                            property kinds

                                                                                                                                            kinds: Set<string>;

                                                                                                                                              property localIds

                                                                                                                                              localIds: LocalId[];

                                                                                                                                                property node

                                                                                                                                                node: any;

                                                                                                                                                  property sourceRange

                                                                                                                                                  sourceRange: SourceRange;

                                                                                                                                                    property template

                                                                                                                                                    template: Template;

                                                                                                                                                      property warnings

                                                                                                                                                      warnings: Warning[];

                                                                                                                                                        class Element

                                                                                                                                                        class Element extends ElementBase implements Feature {}

                                                                                                                                                          constructor

                                                                                                                                                          constructor(init: ElementInit, document: Document<ParsedDocument<{}, {}>>);

                                                                                                                                                            property extends

                                                                                                                                                            extends?: string;
                                                                                                                                                            • For customized built-in elements, the tagname of the builtin element that this element extends.

                                                                                                                                                            property tagName

                                                                                                                                                            readonly tagName: string;

                                                                                                                                                              class ElementBase

                                                                                                                                                              abstract class ElementBase extends Class implements Feature {}
                                                                                                                                                              • Base class for Element and ElementMixin.

                                                                                                                                                              constructor

                                                                                                                                                              constructor(init: ElementBaseInit, document: Document<ParsedDocument<{}, {}>>);

                                                                                                                                                                property 'slots'

                                                                                                                                                                'slots': ImmutableArray<Slot>;

                                                                                                                                                                  property attributes

                                                                                                                                                                  attributes: Map<string, Attribute>;

                                                                                                                                                                    property events

                                                                                                                                                                    events: Map<string, Event>;

                                                                                                                                                                      property template

                                                                                                                                                                      template: ElementTemplate;

                                                                                                                                                                        method emitAttributeMetadata

                                                                                                                                                                        emitAttributeMetadata: (_attribute: Attribute) => Object;

                                                                                                                                                                          method emitEventMetadata

                                                                                                                                                                          emitEventMetadata: (_event: Event) => Object;

                                                                                                                                                                            method inheritFrom

                                                                                                                                                                            protected inheritFrom: (superClass: Class) => void;

                                                                                                                                                                              class ElementMixin

                                                                                                                                                                              class ElementMixin extends ElementBase implements Feature {}

                                                                                                                                                                                constructor

                                                                                                                                                                                constructor(init: ElementMixinInit, document: Document<ParsedDocument<{}, {}>>);

                                                                                                                                                                                  property name

                                                                                                                                                                                  readonly name: string;

                                                                                                                                                                                    class ElementReference

                                                                                                                                                                                    class ElementReference implements Feature {}

                                                                                                                                                                                      constructor

                                                                                                                                                                                      constructor(
                                                                                                                                                                                      scannedRef: ScannedElementReference,
                                                                                                                                                                                      _document: Document<ParsedDocument<{}, {}>>
                                                                                                                                                                                      );

                                                                                                                                                                                        property astNode

                                                                                                                                                                                        readonly astNode: HtmlAstNode;

                                                                                                                                                                                          property attributes

                                                                                                                                                                                          readonly attributes: ImmutableMap<string, Attribute>;

                                                                                                                                                                                            property identifiers

                                                                                                                                                                                            readonly identifiers: ImmutableSet<string>;

                                                                                                                                                                                              property kinds

                                                                                                                                                                                              readonly kinds: ImmutableSet<string>;

                                                                                                                                                                                                property sourceRange

                                                                                                                                                                                                readonly sourceRange: SourceRange;

                                                                                                                                                                                                  property tagName

                                                                                                                                                                                                  readonly tagName: string;

                                                                                                                                                                                                    property warnings

                                                                                                                                                                                                    readonly warnings: ImmutableArray<Warning>;

                                                                                                                                                                                                      class Export

                                                                                                                                                                                                      class Export implements Resolvable, Feature {}

                                                                                                                                                                                                        constructor

                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                        astNode: JsAstNode<any>,
                                                                                                                                                                                                        statementAst: any,
                                                                                                                                                                                                        sourceRange: SourceRange,
                                                                                                                                                                                                        nodePath: any,
                                                                                                                                                                                                        exportingAllFrom?: Iterable<Export>
                                                                                                                                                                                                        );

                                                                                                                                                                                                          property astNode

                                                                                                                                                                                                          readonly astNode: JsAstNode<any>;

                                                                                                                                                                                                            property astNodePath

                                                                                                                                                                                                            readonly astNodePath: any;

                                                                                                                                                                                                              property description

                                                                                                                                                                                                              readonly description: undefined;

                                                                                                                                                                                                                property identifiers

                                                                                                                                                                                                                readonly identifiers: Set<string>;

                                                                                                                                                                                                                  property jsdoc

                                                                                                                                                                                                                  readonly jsdoc: undefined;

                                                                                                                                                                                                                    property kinds

                                                                                                                                                                                                                    readonly kinds: ReadonlySet<string>;

                                                                                                                                                                                                                      property sourceRange

                                                                                                                                                                                                                      readonly sourceRange: SourceRange;

                                                                                                                                                                                                                        property statementAst

                                                                                                                                                                                                                        readonly statementAst: any;

                                                                                                                                                                                                                          property warnings

                                                                                                                                                                                                                          readonly warnings: readonly Warning[];

                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                            resolve: (document: Document) => Feature | undefined;

                                                                                                                                                                                                                              class Feature

                                                                                                                                                                                                                              abstract class Feature {}

                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                sourceRange?: SourceRange,
                                                                                                                                                                                                                                astNode?: AstNodeWithLanguage,
                                                                                                                                                                                                                                warnings?: Warning[] | ImmutableArray<Warning>
                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                  property astNode

                                                                                                                                                                                                                                  readonly astNode?: AstNodeWithLanguage;
                                                                                                                                                                                                                                  • The AST Node, if any, that corresponds to this feature in its containing document.

                                                                                                                                                                                                                                  property identifiers

                                                                                                                                                                                                                                  readonly identifiers: Set<string> | ImmutableSet<string>;

                                                                                                                                                                                                                                    property kinds

                                                                                                                                                                                                                                    readonly kinds: Set<string> | ImmutableSet<string>;

                                                                                                                                                                                                                                      property sourceRange

                                                                                                                                                                                                                                      readonly sourceRange?: SourceRange;
                                                                                                                                                                                                                                      • Tracks the source that this feature came from.

                                                                                                                                                                                                                                      property warnings

                                                                                                                                                                                                                                      readonly warnings: Warning[] | ImmutableArray<Warning>;
                                                                                                                                                                                                                                      • Warnings that were encountered while processing this feature.

                                                                                                                                                                                                                                      class FetchUrlLoader

                                                                                                                                                                                                                                      class FetchUrlLoader implements UrlLoader {}
                                                                                                                                                                                                                                      • Resolves requests via the the DOM fetch API.

                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                      constructor(baseUrl: string);

                                                                                                                                                                                                                                        property baseUrl

                                                                                                                                                                                                                                        baseUrl: string;

                                                                                                                                                                                                                                          method canLoad

                                                                                                                                                                                                                                          canLoad: (_: string) => boolean;

                                                                                                                                                                                                                                            method load

                                                                                                                                                                                                                                            load: (url: string) => Promise<string>;

                                                                                                                                                                                                                                              class FileRelativeUrlBrand

                                                                                                                                                                                                                                              class FileRelativeUrlBrand {}

                                                                                                                                                                                                                                                class FsUrlLoader

                                                                                                                                                                                                                                                class FsUrlLoader implements UrlLoader {}
                                                                                                                                                                                                                                                • Resolves requests via the file system.

                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                constructor(root?: string);

                                                                                                                                                                                                                                                  property root

                                                                                                                                                                                                                                                  root: string;

                                                                                                                                                                                                                                                    method canLoad

                                                                                                                                                                                                                                                    canLoad: (url: ResolvedUrl) => boolean;

                                                                                                                                                                                                                                                      method getFilePath

                                                                                                                                                                                                                                                      getFilePath: (url: ResolvedUrl) => Result<string, string>;
                                                                                                                                                                                                                                                      • If successful, result.value will be the filesystem path that we would load the given url from.

                                                                                                                                                                                                                                                        If unsuccessful, result.value will be an error message as a string.

                                                                                                                                                                                                                                                      method load

                                                                                                                                                                                                                                                      load: (url: ResolvedUrl) => Promise<string>;

                                                                                                                                                                                                                                                        method readDirectory

                                                                                                                                                                                                                                                        readDirectory: (
                                                                                                                                                                                                                                                        pathFromRoot: string,
                                                                                                                                                                                                                                                        deep?: boolean
                                                                                                                                                                                                                                                        ) => Promise<PackageRelativeUrl[]>;

                                                                                                                                                                                                                                                          class FsUrlResolver

                                                                                                                                                                                                                                                          class FsUrlResolver extends UrlResolver {}
                                                                                                                                                                                                                                                          • Resolves package-relative urls to a configured root directory.

                                                                                                                                                                                                                                                            For file-relative URLs it does the normal URL resolution algorithm relative to the base url.

                                                                                                                                                                                                                                                            It does no remapping of urls in source to urls on the filesystem, but a subclass can override modifyFsPath for this purpose.

                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                          constructor(packageDir: string, host?: string, protocol?: string);

                                                                                                                                                                                                                                                            property packageDir

                                                                                                                                                                                                                                                            protected readonly packageDir: string;

                                                                                                                                                                                                                                                              property packageUrl

                                                                                                                                                                                                                                                              protected readonly packageUrl: String & ResolvedUrlBrand;

                                                                                                                                                                                                                                                                property protocol

                                                                                                                                                                                                                                                                protected readonly protocol: string;

                                                                                                                                                                                                                                                                  method filesystemPathForPathname

                                                                                                                                                                                                                                                                  protected filesystemPathForPathname: (decodedPathname: string) => string;

                                                                                                                                                                                                                                                                    method modifyFsPath

                                                                                                                                                                                                                                                                    protected modifyFsPath: (fsPath: string) => string;
                                                                                                                                                                                                                                                                    • Overridable method, for subclasses that want to redirect some filesystem paths.

                                                                                                                                                                                                                                                                      Parameter fsPath

                                                                                                                                                                                                                                                                      An absolute path on the file system. Note that it will be OS-specific. An absolute path on the file system that we should resolve to.

                                                                                                                                                                                                                                                                    method relative

                                                                                                                                                                                                                                                                    relative: {
                                                                                                                                                                                                                                                                    (to: ResolvedUrl): PackageRelativeUrl;
                                                                                                                                                                                                                                                                    (from: ResolvedUrl, to: ResolvedUrl, _kind?: string): FileRelativeUrl;
                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                      method resolve

                                                                                                                                                                                                                                                                      resolve: (
                                                                                                                                                                                                                                                                      firstHref: ResolvedUrl | PackageRelativeUrl,
                                                                                                                                                                                                                                                                      secondHref?: FileRelativeUrl,
                                                                                                                                                                                                                                                                      _import?: ScannedImport
                                                                                                                                                                                                                                                                      ) => ResolvedUrl | undefined;

                                                                                                                                                                                                                                                                        method shouldHandleAsFileUrl

                                                                                                                                                                                                                                                                        protected shouldHandleAsFileUrl: (url: any) => boolean;

                                                                                                                                                                                                                                                                          class Function

                                                                                                                                                                                                                                                                          class Function implements Feature {}

                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                            constructor(scannedFunction: ScannedFunction);

                                                                                                                                                                                                                                                                              property astNode

                                                                                                                                                                                                                                                                              astNode: JsAstNode<any>;

                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                description?: string;

                                                                                                                                                                                                                                                                                  property identifiers

                                                                                                                                                                                                                                                                                  identifiers: Set<string>;

                                                                                                                                                                                                                                                                                    property kinds

                                                                                                                                                                                                                                                                                    kinds: Set<string>;

                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                        params?: { name: string; type?: string }[];

                                                                                                                                                                                                                                                                                          property privacy

                                                                                                                                                                                                                                                                                          privacy: Privacy;

                                                                                                                                                                                                                                                                                            property return

                                                                                                                                                                                                                                                                                            return?: { type?: string; desc?: string };

                                                                                                                                                                                                                                                                                              property sourceRange

                                                                                                                                                                                                                                                                                              sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                property summary

                                                                                                                                                                                                                                                                                                summary?: string;

                                                                                                                                                                                                                                                                                                  property templateTypes

                                                                                                                                                                                                                                                                                                  templateTypes?: string[];

                                                                                                                                                                                                                                                                                                    property warnings

                                                                                                                                                                                                                                                                                                    warnings: Warning[];

                                                                                                                                                                                                                                                                                                      method toString

                                                                                                                                                                                                                                                                                                      toString: () => string;

                                                                                                                                                                                                                                                                                                        class Import

                                                                                                                                                                                                                                                                                                        class Import implements Feature {}

                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                          url: String & ResolvedUrlBrand,
                                                                                                                                                                                                                                                                                                          originalUrl: String & FileRelativeUrlBrand,
                                                                                                                                                                                                                                                                                                          type: string,
                                                                                                                                                                                                                                                                                                          document: Document<ParsedDocument<{}, {}>>,
                                                                                                                                                                                                                                                                                                          sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                          urlSourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                          ast: AstNodeWithLanguage,
                                                                                                                                                                                                                                                                                                          warnings: Warning[],
                                                                                                                                                                                                                                                                                                          lazy: boolean
                                                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                                                            property astNode

                                                                                                                                                                                                                                                                                                            readonly astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                              property document

                                                                                                                                                                                                                                                                                                              readonly document: Document<ParsedDocument<{}, {}>>;

                                                                                                                                                                                                                                                                                                                property identifiers

                                                                                                                                                                                                                                                                                                                readonly identifiers: Set<any>;

                                                                                                                                                                                                                                                                                                                  property kinds

                                                                                                                                                                                                                                                                                                                  readonly kinds: Set<string>;

                                                                                                                                                                                                                                                                                                                    property lazy

                                                                                                                                                                                                                                                                                                                    readonly lazy: boolean;

                                                                                                                                                                                                                                                                                                                      property originalUrl

                                                                                                                                                                                                                                                                                                                      readonly originalUrl: String & FileRelativeUrlBrand;

                                                                                                                                                                                                                                                                                                                        property sourceRange

                                                                                                                                                                                                                                                                                                                        readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                          readonly type: string;

                                                                                                                                                                                                                                                                                                                            property url

                                                                                                                                                                                                                                                                                                                            readonly url: String & ResolvedUrlBrand;

                                                                                                                                                                                                                                                                                                                              property urlSourceRange

                                                                                                                                                                                                                                                                                                                              readonly urlSourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                property warnings

                                                                                                                                                                                                                                                                                                                                readonly warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                  method toString

                                                                                                                                                                                                                                                                                                                                  toString: () => string;

                                                                                                                                                                                                                                                                                                                                    class InlineDocument

                                                                                                                                                                                                                                                                                                                                    class InlineDocument extends Document {}

                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                      base: ScannedDocument,
                                                                                                                                                                                                                                                                                                                                      containerDocument: Document<ParsedDocument<{}, {}>>
                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                        class InMemoryOverlayUrlLoader

                                                                                                                                                                                                                                                                                                                                        class InMemoryOverlayUrlLoader implements UrlLoader {}
                                                                                                                                                                                                                                                                                                                                        • Resolves requests first from an in-memory map of file contents, and if a file isn't found there, defers to another url loader.

                                                                                                                                                                                                                                                                                                                                          Useful for the editor use case. An editor will have a number of files in open buffers at any time. For these files, the editor's in-memory buffer is canonical, so that their contents are read even when they have unsaved changes. For all other files, we can load the files using another loader, e.g. from disk.

                                                                                                                                                                                                                                                                                                                                          TODO(rictic): make this a mixin that mixes another loader.

                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                        constructor(fallbackLoader?: UrlLoader);

                                                                                                                                                                                                                                                                                                                                          property readDirectory

                                                                                                                                                                                                                                                                                                                                          readDirectory?: (
                                                                                                                                                                                                                                                                                                                                          pathFromRoot: string,
                                                                                                                                                                                                                                                                                                                                          deep?: boolean
                                                                                                                                                                                                                                                                                                                                          ) => Promise<PackageRelativeUrl[]>;

                                                                                                                                                                                                                                                                                                                                            property urlContentsMap

                                                                                                                                                                                                                                                                                                                                            urlContentsMap: Map<ResolvedUrl, string>;

                                                                                                                                                                                                                                                                                                                                              method canLoad

                                                                                                                                                                                                                                                                                                                                              canLoad: (url: ResolvedUrl) => boolean;

                                                                                                                                                                                                                                                                                                                                                method load

                                                                                                                                                                                                                                                                                                                                                load: (url: ResolvedUrl) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                  class JavascriptDatabindingExpression

                                                                                                                                                                                                                                                                                                                                                  class JavascriptDatabindingExpression extends DatabindingExpression {}

                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                    astNode: any,
                                                                                                                                                                                                                                                                                                                                                    sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                    expressionText: string,
                                                                                                                                                                                                                                                                                                                                                    ast: any,
                                                                                                                                                                                                                                                                                                                                                    kind: ExpressionLimitation,
                                                                                                                                                                                                                                                                                                                                                    document: JavaScriptDocument
                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                      property astNode

                                                                                                                                                                                                                                                                                                                                                      readonly astNode: any;

                                                                                                                                                                                                                                                                                                                                                        property databindingInto

                                                                                                                                                                                                                                                                                                                                                        readonly databindingInto: string;

                                                                                                                                                                                                                                                                                                                                                          class JavascriptImport

                                                                                                                                                                                                                                                                                                                                                          class JavascriptImport extends Import implements DeclaredWithStatement {}

                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                            url: String & ResolvedUrlBrand,
                                                                                                                                                                                                                                                                                                                                                            originalUrl: String & FileRelativeUrlBrand,
                                                                                                                                                                                                                                                                                                                                                            type: string,
                                                                                                                                                                                                                                                                                                                                                            document: Document<ParsedDocument<{}, {}>>,
                                                                                                                                                                                                                                                                                                                                                            sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                            urlSourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                            ast: JsAstNode<any>,
                                                                                                                                                                                                                                                                                                                                                            astNodePath: any,
                                                                                                                                                                                                                                                                                                                                                            warnings: Warning[],
                                                                                                                                                                                                                                                                                                                                                            lazy: boolean,
                                                                                                                                                                                                                                                                                                                                                            specifier: string,
                                                                                                                                                                                                                                                                                                                                                            statementAst: any
                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                              property astNode

                                                                                                                                                                                                                                                                                                                                                              readonly astNode: JsAstNode<any>;

                                                                                                                                                                                                                                                                                                                                                                property astNodePath

                                                                                                                                                                                                                                                                                                                                                                readonly astNodePath: any;

                                                                                                                                                                                                                                                                                                                                                                  property specifier

                                                                                                                                                                                                                                                                                                                                                                  readonly specifier: string;
                                                                                                                                                                                                                                                                                                                                                                  • The original text of the specifier. Unlike this.url, this may not be a URL, but may be a bare module specifier, like 'jquery'.

                                                                                                                                                                                                                                                                                                                                                                  property statementAst

                                                                                                                                                                                                                                                                                                                                                                  readonly statementAst: any;

                                                                                                                                                                                                                                                                                                                                                                    class MapWithDefault

                                                                                                                                                                                                                                                                                                                                                                    class MapWithDefault<K, V> extends Map<K, V> {}
                                                                                                                                                                                                                                                                                                                                                                    • This is a special map which automatically creates a default value if the key is not found.

                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                    constructor(makeDefault: (key: K) => V);

                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                      get: (key: K) => V;

                                                                                                                                                                                                                                                                                                                                                                        class MultiUrlLoader

                                                                                                                                                                                                                                                                                                                                                                        class MultiUrlLoader implements UrlLoader {}
                                                                                                                                                                                                                                                                                                                                                                        • Resolves requests via one of a sequence of loaders.

                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                        constructor(_loaders: UrlLoader[]);

                                                                                                                                                                                                                                                                                                                                                                          method canLoad

                                                                                                                                                                                                                                                                                                                                                                          canLoad: (url: ResolvedUrl) => boolean;

                                                                                                                                                                                                                                                                                                                                                                            method load

                                                                                                                                                                                                                                                                                                                                                                            load: (url: ResolvedUrl) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                              method readDirectory

                                                                                                                                                                                                                                                                                                                                                                              readDirectory: (
                                                                                                                                                                                                                                                                                                                                                                              path: ResolvedUrl,
                                                                                                                                                                                                                                                                                                                                                                              deep?: boolean
                                                                                                                                                                                                                                                                                                                                                                              ) => Promise<PackageRelativeUrl[]>;

                                                                                                                                                                                                                                                                                                                                                                                class MultiUrlResolver

                                                                                                                                                                                                                                                                                                                                                                                class MultiUrlResolver extends UrlResolver {}
                                                                                                                                                                                                                                                                                                                                                                                • Resolves a URL using multiple resolvers.

                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                constructor(_resolvers: readonly UrlResolver[]);

                                                                                                                                                                                                                                                                                                                                                                                  method relative

                                                                                                                                                                                                                                                                                                                                                                                  relative: {
                                                                                                                                                                                                                                                                                                                                                                                  (to: ResolvedUrl): PackageRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                  (from: ResolvedUrl, to: ResolvedUrl, kind?: string): FileRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                  • Delegates to relative method on the first resolver which can resolve the destination URL.

                                                                                                                                                                                                                                                                                                                                                                                  method resolve

                                                                                                                                                                                                                                                                                                                                                                                  resolve: (
                                                                                                                                                                                                                                                                                                                                                                                  firstUrl: ResolvedUrl | PackageRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                  secondUrl?: FileRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                  import_?: ScannedImport
                                                                                                                                                                                                                                                                                                                                                                                  ) => ResolvedUrl | undefined;
                                                                                                                                                                                                                                                                                                                                                                                  • Returns the first resolved URL (which is not undefined.)

                                                                                                                                                                                                                                                                                                                                                                                  class Namespace

                                                                                                                                                                                                                                                                                                                                                                                  class Namespace implements Feature {}

                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                    constructor(scannedNamespace: ScannedNamespace);

                                                                                                                                                                                                                                                                                                                                                                                      property astNode

                                                                                                                                                                                                                                                                                                                                                                                      astNode: JsAstNode<any>;

                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                        description?: string;

                                                                                                                                                                                                                                                                                                                                                                                          property identifiers

                                                                                                                                                                                                                                                                                                                                                                                          identifiers: Set<string>;

                                                                                                                                                                                                                                                                                                                                                                                            property kinds

                                                                                                                                                                                                                                                                                                                                                                                            kinds: Set<string>;

                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                property properties

                                                                                                                                                                                                                                                                                                                                                                                                readonly properties: Map<string, Property>;

                                                                                                                                                                                                                                                                                                                                                                                                  property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                  sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                    property summary

                                                                                                                                                                                                                                                                                                                                                                                                    summary?: string;

                                                                                                                                                                                                                                                                                                                                                                                                      property warnings

                                                                                                                                                                                                                                                                                                                                                                                                      warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                        method toString

                                                                                                                                                                                                                                                                                                                                                                                                        toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                          class PackageRelativeUrlBrand

                                                                                                                                                                                                                                                                                                                                                                                                          class PackageRelativeUrlBrand {}

                                                                                                                                                                                                                                                                                                                                                                                                            class PackageUrlResolver

                                                                                                                                                                                                                                                                                                                                                                                                            class PackageUrlResolver extends FsUrlResolver {}
                                                                                                                                                                                                                                                                                                                                                                                                            • Resolves a URL to a canonical URL within a package.

                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                            constructor(options?: PackageUrlResolverOptions);

                                                                                                                                                                                                                                                                                                                                                                                                              property componentDir

                                                                                                                                                                                                                                                                                                                                                                                                              readonly componentDir: string;

                                                                                                                                                                                                                                                                                                                                                                                                                method modifyFsPath

                                                                                                                                                                                                                                                                                                                                                                                                                protected modifyFsPath: (path: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                  method relative

                                                                                                                                                                                                                                                                                                                                                                                                                  relative: {
                                                                                                                                                                                                                                                                                                                                                                                                                  (to: ResolvedUrl): PackageRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                  (from: ResolvedUrl, to: ResolvedUrl, _kind?: string): FileRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                    class ParsedCssDocument

                                                                                                                                                                                                                                                                                                                                                                                                                    class ParsedCssDocument extends ParsedDocument<shady.Node, Visitor> {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                      readonly type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                        method [Symbol.iterator]

                                                                                                                                                                                                                                                                                                                                                                                                                        [Symbol.iterator]: () => Iterator<shady.Node>;

                                                                                                                                                                                                                                                                                                                                                                                                                          method sourceRangeForNode

                                                                                                                                                                                                                                                                                                                                                                                                                          sourceRangeForNode: (node: any) => SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                            method sourceRangeForShadyRange

                                                                                                                                                                                                                                                                                                                                                                                                                            sourceRangeForShadyRange: (range: any) => SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                            • Takes a range from a shadycss node directly, rather than a shadycss node. Useful when there are multiple ranges for a given node.

                                                                                                                                                                                                                                                                                                                                                                                                                            method stringify

                                                                                                                                                                                                                                                                                                                                                                                                                            stringify: (options?: StringifyOptions) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                              method visit

                                                                                                                                                                                                                                                                                                                                                                                                                              visit: (visitors: Visitor[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                class ParsedDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                abstract class ParsedDocument<AstNode = {} | null | undefined, Visitor = {}> {}
                                                                                                                                                                                                                                                                                                                                                                                                                                • A parsed Document.

                                                                                                                                                                                                                                                                                                                                                                                                                                  AstNode The AST type of the document. Visitor The type of the visitors that can walk the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(from: Options<AstNode>);

                                                                                                                                                                                                                                                                                                                                                                                                                                  property ast

                                                                                                                                                                                                                                                                                                                                                                                                                                  ast: {};

                                                                                                                                                                                                                                                                                                                                                                                                                                    property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly astNode: AstNodeWithLanguage;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • If not null, this is an inline document, and astNode is the AST Node of this document inside of the parent. (e.g. the or tag)

                                                                                                                                                                                                                                                                                                                                                                                                                                    property baseUrl

                                                                                                                                                                                                                                                                                                                                                                                                                                    baseUrl: String & ResolvedUrlBrand;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property contents

                                                                                                                                                                                                                                                                                                                                                                                                                                      contents: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property isInline

                                                                                                                                                                                                                                                                                                                                                                                                                                        isInline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property newlineIndexes

                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly newlineIndexes: number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                          • The 0-based offsets into contents of all newline characters.

                                                                                                                                                                                                                                                                                                                                                                                                                                            Useful for converting between string offsets and SourcePositions.

                                                                                                                                                                                                                                                                                                                                                                                                                                          property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property url

                                                                                                                                                                                                                                                                                                                                                                                                                                              url: String & ResolvedUrlBrand;

                                                                                                                                                                                                                                                                                                                                                                                                                                                method absoluteToRelativeSourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                absoluteToRelativeSourceRange: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                (sourceRange: SourceRange): SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                (sourceRange: undefined): undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                (sourceRange: SourceRange): SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                  method offsetsToSourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                  offsetsToSourceRange: (start: number, end: number) => SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method offsetToSourcePosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                    offsetToSourcePosition: (offset: number) => SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method relativeToAbsoluteSourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                      relativeToAbsoluteSourceRange: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (sourceRange: SourceRange): SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (sourceRange: undefined): undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      (sourceRange: SourceRange): SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sourcePositionToOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourcePositionToOffset: (position: SourcePosition) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method sourceRangeForNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceRangeForNode: (node: AstNode) => SourceRange | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sourceRangeToOffsets

                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceRangeToOffsets: (range: SourceRange) => [number, number];

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract stringify: (options: StringifyOptions) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Convert this.ast back into a string document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                              toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract visit: (visitors: Visitor[]) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Runs a set of document-type specific visitors against the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ParsedHtmlDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ParsedHtmlDocument extends ParsedDocument<ASTNode, HtmlVisitor> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method sourceRangeForAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceRangeForAttribute: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    attrName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => SourceRange | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method sourceRangeForAttributeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceRangeForAttributeName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      attrName: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => SourceRange | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sourceRangeForAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceRangeForAttributeValue: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        attrName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        excludeQuotes?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => SourceRange | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method sourceRangeForEndTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceRangeForEndTag: (node: any) => SourceRange | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method sourceRangeForStartTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceRangeForStartTag: (node: any) => SourceRange | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              stringify: (options?: StringifyOptions) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                visit: (visitors: HtmlVisitor[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ParsedJavaScriptDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class JavaScriptDocument extends ParsedDocument<Node, Visitor> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(from: Options);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ast

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ast: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property parsedAsSourceType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parsedAsSourceType: 'script' | 'module';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • How the js document was parsed. If 'module' then the source code is definitely an ES6 module, as it has imports or exports. If 'script' then it may be an ES6 module with no imports or exports, or it may be a script.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          stringify: (options?: StringifyOptions) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            visit: (visitors: Visitor[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ParsedJsonDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ParsedJsonDocument extends ParsedDocument<Json, Visitor> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stringify: (options?: StringifyOptions) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method visit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    visit: (visitors: Visitor[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class PolymerBehavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Behavior extends PolymerElement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scannedBehavior: ScannedBehavior,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        document: Document<ParsedDocument<{}, {}>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tagName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly tagName: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class PolymerDatabindingExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract class DatabindingExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expressionText: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ast: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                limitation: ExpressionLimitation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                document: ParsedDocument<{}, {}>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property expressionText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly expressionText: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    properties: { name: string; sourceRange: SourceRange }[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Toplevel properties on the model that are referenced in this expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      e.g. in {{foo(bar, baz.zod)}} the properties are foo, bar, and baz (but not zod).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method sourceRangeForNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceRangeForNode: (node: any) => SourceRange | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Given an estree node in this databinding expression, give its source range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PolymerElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PolymerElement extends Element implements PolymerExtension {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          scannedElement: ScannedPolymerElement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          document: Document<ParsedDocument<{}, {}>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property behaviorAssignments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly behaviorAssignments: ImmutableArray<ScannedReference<'behavior'>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property domModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly domModule?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isLegacyFactoryCall

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly isLegacyFactoryCall: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • true iff element was defined using the legacy Polymer() function.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property listeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly listeners: ImmutableArray<{ event: string; handler: string }>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property localIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly localIds: ImmutableArray<LocalId>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property observers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly observers: ImmutableArray<Observer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly properties: Map<string, PolymerProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method emitPropertyMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        emitPropertyMetadata: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property: PolymerProperty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        polymer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        notify: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        observer: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readOnly: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        attributeType: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PolymerElementMixin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class PolymerElementMixin extends ElementMixin implements PolymerExtension {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            scannedMixin: ScannedPolymerElementMixin,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            document: Document<ParsedDocument<{}, {}>>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property behaviorAssignments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly behaviorAssignments: ScannedReference<'behavior'>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property listeners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly listeners: { event: string; handler: string }[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property localIds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly localIds: LocalId[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property observers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly observers: Observer[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly properties: Map<string, PolymerProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pseudo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly pseudo: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method emitPropertyMetadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          emitPropertyMetadata: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property: PolymerProperty
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          polymer: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          notify: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          observer: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readOnly: boolean | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          attributeType: string | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PrefixedUrlLoader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class PrefixedUrlLoader implements UrlLoader {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Resolves requests via a given delegate loader for URLs matching a given prefix. URLs are provided to their delegate without the prefix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(prefix: string, delegate: UrlLoader);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property delegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              delegate: UrlLoader;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property prefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                prefix: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method canLoad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  canLoad: (url: ResolvedUrl) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method load

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    load: (url: ResolvedUrl) => Promise<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class RedirectResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class RedirectResolver extends UrlResolver {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Resolves a URL having one prefix to another URL with a different prefix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      packageUrl: String & ResolvedUrlBrand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _redirectFrom: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      _redirectTo: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method relative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        relative: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (to: ResolvedUrl): PackageRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        (from: ResolvedUrl, to: ResolvedUrl, kind?: string): FileRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resolve: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          firstUrl: ResolvedUrl | PackageRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          secondUrl?: FileRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          _import?: ScannedImport
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ResolvedUrl | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Reference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class Reference<F extends Feature> implements Feature {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A reference to another feature by identifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            identifier: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            astNode: AstNodeWithLanguage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            feature: Feature,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            warnings: readonly Warning[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property feature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly feature: Feature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly identifier: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property identifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly identifiers: ReadonlySet<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kinds

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly kinds: ReadonlySet<'reference'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly warnings: readonly Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ResolvedUrlBrand

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ResolvedUrlBrand {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ScannedClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ScannedClass implements ScannedFeature, Resolvable {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Represents a JS class as encountered in source code.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                We only emit a ScannedClass when there's not a more specific kind of feature. Like, we don't emit a ScannedClass when we encounter an element or a mixin (though in the future those features will likely extend from ScannedClass/Class).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TODO(rictic): currently there's a ton of duplicated code across the Class, Element, Mixin, PolymerElement, and PolymerMixin classes. We should really unify this stuff to a single representation and set of algorithms.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              className: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              localClassName: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              astNode: AstNodeWithLanguage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              statementAst: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jsdoc: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              description: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              properties: Map<string, ScannedProperty>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              methods: Map<string, ScannedMethod>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructorMethod: ScannedMethod,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              staticMethods: Map<string, ScannedMethod>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              superClass: ScannedReference<'class'>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              mixins: ScannedReference<'element-mixin'>[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              privacy: Privacy,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              warnings: Warning[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              demos: Demo[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property abstract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly abstract: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property constructorMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly constructorMethod?: ScannedMethod;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property demos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly demos: Demo[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property jsdoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly jsdoc: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property localName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly localName: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The name of the class in the local scope where it is defined.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property methods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly methods: ImmutableMap<string, ScannedMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property mixins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly mixins: ScannedReference<'element-mixin'>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property privacy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly privacy: Privacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly properties: Map<string, ScannedProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property statementAst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly statementAst: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property staticMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly staticMethods: ImmutableMap<string, ScannedMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property summary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly summary: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property superClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly superClass: ScannedReference<'class'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method finishInitialization

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  finishInitialization: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  methods: Map<string, ScannedMethod>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  properties: Map<string, ScannedProperty>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Allows additional properties and methods to be added to the class after initialization. For example, members found attached to the prototype at a later place in the document

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolve: (document: Document) => Feature | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScannedDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScannedDocument {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The metadata for all features and elements defined in one document

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    document: ParsedDocument<{}, {}>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    features: ScannedFeature[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    warnings?: Warning[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property document

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        document: ParsedDocument<{}, {}>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property features

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          features: ScannedFeature[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isInline

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isInline: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly url: String & ResolvedUrlBrand;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getNestedFeatures

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getNestedFeatures: () => ScannedFeature[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Gets all features in this scanned document and all inline documents it contains.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScannedElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class ScannedElement extends ScannedElementBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property extends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        extends?: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • For customized built-in elements, the tagname of the superClass.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property superClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          superClass?: ScannedReference<'class'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tagName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            tagName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolve: (document: Document) => Element;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ScannedElementBase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract class ScannedElementBase implements Resolvable {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Base class for ScannedElement and ScannedElementMixin.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property 'slots'

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                'slots': Slot[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property abstract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      attributes: Map<string, ScannedAttribute>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property demos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        demos: Demo[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property events

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            events: Map<string, ScannedEvent>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property jsdoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jsdoc?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property methods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                methods: Map<string, ScannedMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property mixins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  mixins: ScannedReference<'element-mixin'>[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property privacy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    privacy: Privacy;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property properties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      properties: Map<string, ScannedProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property statementAst

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          statementAst: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property staticMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            staticMethods: Map<string, ScannedMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property summary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              summary: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property superClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                superClass?: ScannedReference<'class'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method applyHtmlComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    applyHtmlComment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    commentText: string | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    containingDocument: ParsedDocument | undefined
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract resolve: (_document: Document) => Feature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ScannedElementMixin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class ScannedElementMixin extends ScannedElementBase {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor({ name }: { name: string });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property abstract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly abstract: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolve: (document: Document) => ElementMixin;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ScannedElementReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ScannedElementReference implements Resolvable {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(tagName: string, sourceRange: SourceRange, ast: HtmlAstNode);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly astNode: HtmlAstNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly attributes: Map<string, Attribute>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property tagName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly tagName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly warnings: ImmutableArray<Warning>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                resolve: (document: Document) => ElementReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class ScannedFeature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract class ScannedFeature {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    sourceRange?: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    astNode?: AstNodeWithLanguage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    description?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    jsdoc?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    warnings?: Warning[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly astNode?: AstNodeWithLanguage;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • The AST Node, if any, that corresponds to this feature in its containing document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly description?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property jsdoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly jsdoc?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly sourceRange: SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Tracks the source that this feature came from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly warnings: Warning[] | ImmutableArray<Warning>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Warnings that were encountered while processing this feature.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ScannedImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ScannedImport implements Resolvable {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Represents an import, such as an HTML import, an external script or style tag, or an JavaScript import.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            N The AST node type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          url: String & FileRelativeUrlBrand,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          urlSourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ast: AstNodeWithLanguage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          lazy: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property error

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              error: { message?: string };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lazy

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lazy: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • If true, the imported document may not be loaded until well after the containing document has been evaluated, and indeed may never load.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    url: String & FileRelativeUrlBrand;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • URL of the import, relative to the base directory.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property urlSourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    urlSourceRange: SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The source range specifically for the URL or reference to the imported resource.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method addCouldNotLoadWarning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected addCouldNotLoadWarning: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      document: Document,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      warning?: Warning
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method constructImport

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected constructImport: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        resolvedUrl: ResolvedUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        relativeUrl: FileRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        importedDocument: Document | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        _containingDocument: Document
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Import;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getLoadableUrlOrWarn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected getLoadableUrlOrWarn: (document: Document) => ResolvedUrl | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Resolve the URL for this import and return it if the analyzer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resolve: (document: Document) => Import | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ScannedInlineDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class ScannedInlineDocument implements ScannedFeature, Resolvable {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Represents an inline document, usually a or tag in an HTML document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              N The AST node type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contents: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            locationOffset: LocationOffset,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            attachedComment: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            astNode: AstNodeWithLanguage
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property attachedComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly attachedComment?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property contents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly contents: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property locationOffset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly locationOffset: LocationOffset;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The location offset of this document within the containing document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property scannedDocument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    scannedDocument?: ScannedDocument;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property warnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly warnings: Warning[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolve: (document: Document) => Document | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ScannedReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class ScannedReference<K extends keyof FeatureKindMap>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extends ScannedFeature
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              implements Resolvable {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • A reference to another feature by identifier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind: keyof FeatureKindMap,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              identifier: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              sourceRange: SourceRange,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              astNode: AstNodeWithLanguage,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              astPath: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              description?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              jsdoc?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              warnings?: Warning[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly astNode: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property astPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly astPath: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly identifier: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly kind: keyof FeatureKindMap;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          resolve: (document: Document) => Reference<FeatureKindMap[K]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method resolveWithKind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolveWithKind: <DK extends keyof FeatureKindMap>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            document: Document,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            kind: DK
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Reference<FeatureKindMap[DK]>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Slot

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Slot {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(name: string, range: SourceRange, astNode: AstNodeWithLanguage);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  astNode?: AstNodeWithLanguage;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      range: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class UrlResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract class UrlResolver {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Resolves the given URL to the concrete URL that a resource can be loaded from.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          This can be useful to resolve name to paths, such as resolving 'polymer' to '../polymer/polymer.html', or component paths, like '../polymer/polymer.html' to '/bower_components/polymer/polymer.html'.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method brandAsFileRelative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected brandAsFileRelative: (url: string) => FileRelativeUrl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method brandAsPackageRelative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          protected brandAsPackageRelative: (url: string) => PackageRelativeUrl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method brandAsResolved

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            protected brandAsResolved: (url: string) => ResolvedUrl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getBaseAndUnresolved

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              protected getBaseAndUnresolved: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url1: PackageRelativeUrl | ResolvedUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              url2?: FileRelativeUrl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => [ResolvedUrl | undefined, FileRelativeUrl | PackageRelativeUrl];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method relative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract relative: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (to: ResolvedUrl): PackageRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (from: ResolvedUrl, to: ResolvedUrl, kind?: string): FileRelativeUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method resolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract resolve: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (url: PackageRelativeUrl): ResolvedUrl | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  baseUrl: ResolvedUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  url: FileRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scannedImport?: ScannedImport
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ): ResolvedUrl;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Resoves url to a new location.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Returns undefined if the given url cannot be resolved.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method simpleUrlRelative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  protected simpleUrlRelative: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  from: ResolvedUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  to: ResolvedUrl
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => FileRelativeUrl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method simpleUrlResolve

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    protected simpleUrlResolve: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    baseUrl: ResolvedUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    url: FileRelativeUrl | PackageRelativeUrl,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    defaultProtocol: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ResolvedUrl;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Warning {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(init: WarningInit);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property actions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly actions: readonly Action[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Other actions that could be taken in response to this warning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Each action is separate and they may be mutually exclusive. In the case of edit actions they often are.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property code

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly code: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly fix: Edit;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • If the problem has a single automatic fix, this is it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Whether and how much something is 'automatic' can be a bit tricky to delineate. Roughly speaking, if 99% of the time the change solves the issue completely then it should go in fix.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property severity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly severity: Severity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property sourceRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly sourceRange: SourceRange;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toJSON: () => {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  code: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  message: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  severity: Severity;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  sourceRange: SourceRange;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toString: (options?: Partial<WarningStringifyOptions>) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class WarningCarryingException

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class WarningCarryingException extends Error {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(warning: Warning);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property warning

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly warning: Warning;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class WarningFilter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class WarningFilter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              constructor(options: Options);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property fileGlobsToFilterOut

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fileGlobsToFilterOut: readonly any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property minimumSeverity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  minimumSeverity: Severity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property warningCodesToIgnore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    warningCodesToIgnore: ReadonlySet<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method shouldIgnore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      shouldIgnore: (warning: Warning) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class WarningPrinter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class WarningPrinter {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(_outStream: any, options?: Partial<WarningStringifyOptions>);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method printWarnings

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            printWarnings: (warnings: Iterable<Warning>) => Promise<void>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Convenience method around printWarning.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Interfaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface AnalysisFormat

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Analysis {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • The global namespace of features contained in an analysis.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Top-level members are unnamespaced, everything else is contained in a namespace. Often an analysis will contain only one namespace at the root.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property classes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            classes?: Class[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All toplevel classes found that were not covered by one of the other types.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              e.g. classes that are elements are only found in elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            elements?: Element[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All elements found.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property functions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            functions?: Function[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All toplevel functions found.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property metadata

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            metadata?: any;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • An extension point for framework-specific metadata, as well as any metadata not yet standardized here such as what polyfills are needed, behaviors and mixins used, the framework that the package was written in, tags/categories, framework config files, etc.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Framework-specific metadata should be put into a sub-object with the name of that framework.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mixins

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mixins?: ElementMixin[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All element mixins found.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property namespaces

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespaces?: Namespace[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • All toplevel namespaces found.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property schema_version

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            schema_version: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface AnalyzerOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property lazyEdges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                lazyEdges?: LazyEdgeMap;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Map from url of an HTML Document to another HTML document it lazily depends on.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property moduleResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                moduleResolution?: 'node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Algorithm to use for resolving module specifiers in import and export statements when rewriting them to be web-compatible. A value of 'node' uses Node.js resolution to find modules.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parsers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parsers?: Map<string, Parser<ParsedDocument>>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property scanners

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  scanners?: ScannerTable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property urlLoader

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    urlLoader: UrlLoader;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property urlResolver

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      urlResolver?: UrlResolver;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Attribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Attribute extends ScannedAttribute {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inheritedFrom

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly inheritedFrom?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ClassInit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ClassInit {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property abstract

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly abstract: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property astNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly astNode: AstNodeWithLanguage | undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property className

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly className?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property constructorMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly constructorMethod?: Method;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property demos