• Version 3.1.4
  • Published
  • 763 kB
  • 65 dependencies
  • BSD-3-Clause license


npm i polymer-build
yarn add polymer-build
pnpm add polymer-build


A library of Gulp build tasks



function addCustomElementsEs5Adapter

addCustomElementsEs5Adapter: (html: string) => string;
  • Please avoid using this function because the API is likely to change. Prefer the interface provided by PolymerProject.addCustomElementsEs5Adapter.

    When compiling ES6 classes down to ES5 we need to include a special shim so that compiled custom elements will still work on browsers that support native custom elements.

    TODO(fks) 03-28-2017: Add tests.

function addServiceWorker

addServiceWorker: (options: AddServiceWorkerOptions) => Promise<void>;
  • Returns a promise that resolves when a service worker has been generated and written to the build directory. This uses generateServiceWorker() to generate a service worker, which it then writes to the file system based on the buildRoot & path (if provided) options.

function forkStream

forkStream: (stream: NodeJS.ReadableStream) => NodeJS.ReadableStream;

    function generateServiceWorker

    generateServiceWorker: (options: AddServiceWorkerOptions) => Promise<Buffer>;
    • Returns a promise that resolves with a generated service worker (the file contents), based off of the options provided.

    function getOptimizeStreams

    getOptimizeStreams: (options?: OptimizeOptions) => NodeJS.ReadWriteStream[];
    • Returns an array of optimization streams to use in your build, based on the OptimizeOptions given.

    function htmlTransform

    htmlTransform: (html: string, options: HtmlTransformOptions) => string;
    • Transform some HTML according to the given options.

    function jsTransform

    jsTransform: (js: string, options: JsTransformOptions) => string;
    • Transform some JavaScript according to the given options.

    function resolveBareSpecifiers

    resolveBareSpecifiers: (
    filePath: string,
    isComponentRequest: boolean,
    packageName?: string | undefined,
    componentDir?: string | undefined,
    rootDir?: string | undefined
    ) => {
    inherits: any;
    visitor: {
    Program(path: NodePath<Program>): void;
    path: NodePath<HasSpecifier>
    ): void;
    • Rewrites so-called "bare module specifiers" to be web-compatible paths.


    class BuildAnalyzer

    class BuildAnalyzer {}


      constructor(config: ProjectConfig, streamToWarnTo?: any);

        property allFragmentsToAnalyze

        allFragmentsToAnalyze: Set<LocalFsPath>;

          property analyzeDependencies

          analyzeDependencies: Promise<DepsIndex>;

            property analyzer

            analyzer: Analyzer;

              property config

              config: ProjectConfig;

                property files

                files: Map<PackageRelativeUrl, File>;

                  property loader

                  loader: StreamLoader;

                    property sourceFilesLoaded

                    sourceFilesLoaded: boolean;

                      property started

                      started: boolean;

                        property warnings

                        warnings: Set<Warning>;

                          method addFile

                          addFile: (file: File) => void;
                          • A side-channel to add files to the loader that did not come through the stream transformation. This is for generated files, like shared-bundle.html. This should probably be refactored so that the files can be injected into the stream.

                          method analyzeFile

                          analyzeFile: (file: File) => Promise<void>;
                          • Analyze a file to find additional dependencies to load. Currently we only get dependencies for application fragments. When all fragments are analyzed, we call _done() to signal that analysis is complete.

                          method dependencies

                          dependencies: () => NodeJS.ReadableStream;
                          • Return _dependenciesOutputStream, which will contain fully loaded file objects for each dependency after analysis.

                          method dependencyPathAnalyzed

                          dependencyPathAnalyzed: (filePath: LocalFsPath) => void;
                          • Push the given filepath into the dependencies stream for loading. Each dependency is only pushed through once to avoid duplicates.

                          method getFile

                          getFile: (filepath: LocalFsPath) => File | undefined;

                            method getFileByUrl

                            getFileByUrl: (url: PackageRelativeUrl) => File | undefined;

                              method printWarnings

                              printWarnings: () => void;

                                method resolveFile

                                resolveFile: (file: File) => void;
                                • Resolve a file in our loader so that the analyzer can read it.

                                method sourcePathAnalyzed

                                sourcePathAnalyzed: (filePath: LocalFsPath) => void;
                                • Check that the source stream has not already completed loading by the time this file was analyzed.

                                method sources

                                sources: () => NodeJS.ReadableStream;
                                • Return _sourcesOutputStream, which will contain fully loaded file objects for each source after analysis.

                                method startAnalysis

                                startAnalysis: () => void;
                                • Start analysis by setting up the sources and dependencies analysis pipelines and starting the source stream. Files will not be loaded from disk until this is called. Can be called multiple times but will only run set up once.

                                class BuildBundler

                                class BuildBundler extends AsyncTransformStream<File, File> {}


                                  config: ProjectConfig,
                                  buildAnalyzer: BuildAnalyzer,
                                  options?: Options

                                    property config

                                    config: ProjectConfig;

                                      property files

                                      files: Map<ResolvedUrl, File>;

                                        class HtmlSplitter

                                        class HtmlSplitter {}
                                        • HTMLSplitter represents the shared state of files as they are passed through a splitting stream and then a rejoining stream. Creating a new instance of HTMLSplitter and adding its streams to the build pipeline is the supported user interface for splitting out and rejoining inlined CSS & JS in the build process.

                                        method addSplitPath

                                        addSplitPath: (parentPath: string, childPath: string) => void;

                                          method getParentFile

                                          getParentFile: (childPath: string) => SplitFile | undefined;

                                            method getSplitFile

                                            getSplitFile: (parentPath: string) => SplitFile;

                                              method isSplitFile

                                              isSplitFile: (parentPath: string) => boolean;

                                                method rejoin

                                                rejoin: () => Transform;
                                                • Returns a new Transform stream that rejoins inline scripts and styles that were originally split from this HTMLSplitter's split() back into their parent HTML files.

                                                method split

                                                split: () => Transform;
                                                • Returns a new Transform stream that splits inline script and styles into new, separate files that are passed out of the stream.

                                                class PolymerProject

                                                class PolymerProject {}


                                                  constructor(config: any);

                                                    property analyzer

                                                    analyzer: BuildAnalyzer;
                                                    • A Transform stream that uses polymer-analyzer to analyze the files. It can be used to get information on dependencies and fragments for the project once the source & dependency streams have been piped into it.

                                                    property config

                                                    config: ProjectConfig;

                                                      method addBabelHelpersInEntrypoint

                                                      addBabelHelpersInEntrypoint: (entrypoint?: string) => NodeJS.ReadWriteStream;

                                                        method addCustomElementsEs5Adapter

                                                        addCustomElementsEs5Adapter: () => NodeJS.ReadWriteStream;
                                                        • Returns a stream transformer that injects custom-elements-es5-adapter.js into the entry point HTML file. This adapter is needed when serving ES5 to browsers that support the native Custom Elements API.

                                                        addPrefetchLinks: () => NodeJS.ReadWriteStream;
                                                        • Returns a stream transformer that injects 'prefetch' link tags into HTML documents based on the transitive dependencies of the document. For entrypoint documents without <base> tag, absolute urls are used in prefetch link hrefs. In all other cases, link hrefs will be relative urls.

                                                        method addPushManifest

                                                        addPushManifest: (
                                                        outPath?: LocalFsPath,
                                                        basePath?: PackageRelativeUrl
                                                        ) => NodeJS.ReadWriteStream;
                                                        • Returns a stream transformer that adds a push manifest file to the set of all input files that pass through.

                                                        method bundler

                                                        bundler: (options?: BuildBundlerOptions) => BuildBundler;
                                                        • Returns a Transform stream that modifies the files that pass through it based on the dependency analysis done by the analyzer transform. It "bundles" a project by injecting its dependencies into the application fragments themselves, so that a minimum number of requests need to be made to load.

                                                          (NOTE: The analyzer stream must be in the pipeline somewhere before this.)

                                                        method dependencies

                                                        dependencies: () => NodeJS.ReadableStream;
                                                        • Returns the analyzer's stream of this project's dependency files - files loaded inside the analyzed project that are not considered source files.

                                                        method sources

                                                        sources: () => NodeJS.ReadableStream;
                                                        • Returns the analyzer's stream of this project's source files - files matched by the project's config.sources value.

                                                        method updateBaseTag

                                                        updateBaseTag: (baseHref: string) => NodeJS.ReadWriteStream;
                                                        • Return a stream transformer that updates the <base> tag of the project's entrypoint HTML file with the given new value. No change is made if a <base> tag does not already exist.


                                                        interface AddServiceWorkerOptions

                                                        interface AddServiceWorkerOptions {}

                                                          property basePath

                                                          basePath?: LocalFsPath;

                                                            property buildRoot

                                                            buildRoot: LocalFsPath;

                                                              property bundled

                                                              bundled?: boolean;

                                                                property path

                                                                path?: LocalFsPath;

                                                                  property project

                                                                  project: PolymerProject;

                                                                    property swPrecacheConfig

                                                                    swPrecacheConfig?: SWConfig | null;

                                                                      interface DepsIndex

                                                                      interface DepsIndex {}

                                                                        property depsToFragments

                                                                        depsToFragments: Map<PackageRelativeUrl, PackageRelativeUrl[]>;

                                                                          property fragmentToDeps

                                                                          fragmentToDeps: Map<PackageRelativeUrl, PackageRelativeUrl[]>;

                                                                            property fragmentToFullDeps

                                                                            fragmentToFullDeps: Map<PackageRelativeUrl, DocumentDeps>;

                                                                              interface OptimizeOptions

                                                                              interface OptimizeOptions {}

                                                                                property css

                                                                                css?: {
                                                                                | boolean
                                                                                | {
                                                                                exclude?: string[];

                                                                                  property entrypointPath

                                                                                  entrypointPath?: string;

                                                                                    property html

                                                                                    html?: {
                                                                                    | boolean
                                                                                    | {
                                                                                    exclude?: string[];

                                                                                      property js

                                                                                      js?: JsOptimizeOptions;

                                                                                        property rootDir

                                                                                        rootDir?: string;

                                                                                          interface SWConfig

                                                                                          interface SWConfig {}

                                                                                            property cacheId

                                                                                            cacheId?: string;

                                                                                              property directoryIndex

                                                                                              directoryIndex?: string;

                                                                                                property dynamicUrlToDependencies

                                                                                                dynamicUrlToDependencies?: {
                                                                                                [property: string]: string[];

                                                                                                  property handleFetch

                                                                                                  handleFetch?: boolean;

                                                                                                    property ignoreUrlParametersMatching

                                                                                                    ignoreUrlParametersMatching?: RegExp[];

                                                                                                      property importScripts

                                                                                                      importScripts?: string[];

                                                                                                        property logger

                                                                                                        logger?: Function;

                                                                                                          property maximumFileSizeToCacheInBytes

                                                                                                          maximumFileSizeToCacheInBytes?: number;

                                                                                                            property navigateFallback

                                                                                                            navigateFallback?: string;

                                                                                                              property navigateFallbackWhitelist

                                                                                                              navigateFallbackWhitelist?: RegExp[];

                                                                                                                property replacePrefix

                                                                                                                replacePrefix?: string;

                                                                                                                  property runtimeCaching

                                                                                                                  runtimeCaching?: {
                                                                                                                  urlPattern: RegExp;
                                                                                                                  handler: string;
                                                                                                                  options?: {
                                                                                                                  cache: {
                                                                                                                  maxEntries: number;
                                                                                                                  name: string;

                                                                                                                    property staticFileGlobs

                                                                                                                    staticFileGlobs?: string[];

                                                                                                                      property stripPrefix

                                                                                                                      stripPrefix?: string;

                                                                                                                        property templateFilePath

                                                                                                                        templateFilePath?: string;

                                                                                                                          property verbose

                                                                                                                          verbose?: boolean;


                                                                                                                            namespace @babel/core

                                                                                                                            module '@babel/core' {}

                                                                                                                              namespace @babel/helper-plugin-utils

                                                                                                                              module '@babel/helper-plugin-utils' {}

                                                                                                                                namespace @babel/plugin-syntax-dynamic-import

                                                                                                                                module '@babel/plugin-syntax-dynamic-import' {}

                                                                                                                                  namespace @babel/plugin-syntax-import-meta

                                                                                                                                  module '@babel/plugin-syntax-import-meta' {}

                                                                                                                                    namespace @babel/template

                                                                                                                                    module '@babel/template' {}

                                                                                                                                      namespace @babel/traverse

                                                                                                                                      module '@babel/traverse' {}

                                                                                                                                        class Binding

                                                                                                                                        class Binding {}


                                                                                                                                          constructor(opts: {
                                                                                                                                          existing: Binding;
                                                                                                                                          identifier: t.Identifier;
                                                                                                                                          scope: Scope;
                                                                                                                                          path: NodePath;
                                                                                                                                          kind: 'var' | 'let' | 'const';

                                                                                                                                            property constant

                                                                                                                                            constant: boolean;

                                                                                                                                              property constantViolations

                                                                                                                                              constantViolations: NodePath<t.Node>[];

                                                                                                                                                property identifier

                                                                                                                                                identifier: t.Identifier;

                                                                                                                                                  property kind

                                                                                                                                                  kind: 'var' | 'let' | 'const' | 'module';

                                                                                                                                                    property path

                                                                                                                                                    path: NodePath<t.Node>;

                                                                                                                                                      property referenced

                                                                                                                                                      referenced: boolean;

                                                                                                                                                        property referencePaths

                                                                                                                                                        referencePaths: NodePath<t.Node>[];

                                                                                                                                                          property references

                                                                                                                                                          references: number;

                                                                                                                                                            property scope

                                                                                                                                                            scope: Scope;

                                                                                                                                                              class NodePath

                                                                                                                                                              class NodePath<T = Node> {}

                                                                                                                                                                property node

                                                                                                                                                                node: {};

                                                                                                                                                                  property scope

                                                                                                                                                                  scope: Scope;

                                                                                                                                                                    method replaceExpressionWithStatements

                                                                                                                                                                    replaceExpressionWithStatements: (nodes: Node[]) => t.Node;
                                                                                                                                                                    • This method takes an array of statements nodes and then explodes it into expressions. This method retains completion records which is extremely important to retain original semantics.

                                                                                                                                                                    method replaceInline

                                                                                                                                                                    replaceInline: (nodes: Node | Node[]) => void;

                                                                                                                                                                      method replaceWith

                                                                                                                                                                      replaceWith: (replacement: Node | NodePath) => void;
                                                                                                                                                                      • Replace the current node with another.

                                                                                                                                                                      method replaceWithMultiple

                                                                                                                                                                      replaceWithMultiple: (nodes: Node[]) => void;
                                                                                                                                                                      • Replace a node with an array of multiple. This method performs the following steps:

                                                                                                                                                                        - Inherit the comments of first provided node with that of the current node. - Insert the provided nodes after the current node. - Remove the current node.

                                                                                                                                                                      method replaceWithSourceString

                                                                                                                                                                      replaceWithSourceString: (replacement: any) => void;
                                                                                                                                                                      • Parse a string as an expression and replace the current node with the result.

                                                                                                                                                                        NOTE: This is typically not a good idea to use. Building source strings when transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's easier to use, your transforms will be extremely brittle.

                                                                                                                                                                      method traverse

                                                                                                                                                                      traverse: (visitor: Visitor, state?: any) => void;

                                                                                                                                                                        class Scope

                                                                                                                                                                        class Scope {}


                                                                                                                                                                          constructor(path: NodePath<t.Node>, parentScope?: Scope);

                                                                                                                                                                            property bindings

                                                                                                                                                                            bindings: { [name: string]: Binding };

                                                                                                                                                                              property block

                                                                                                                                                                              block: t.Node;

                                                                                                                                                                                property parent

                                                                                                                                                                                parent: Scope;

                                                                                                                                                                                  property parentBlock

                                                                                                                                                                                  parentBlock: t.Node;

                                                                                                                                                                                    property path

                                                                                                                                                                                    path: NodePath<t.Node>;

                                                                                                                                                                                      method generateDeclaredUidIdentifier

                                                                                                                                                                                      generateDeclaredUidIdentifier: (name?: string) => t.Identifier;
                                                                                                                                                                                      • Generate a unique identifier and add it to the current scope.

                                                                                                                                                                                      method generateUid

                                                                                                                                                                                      generateUid: (name?: string) => string;
                                                                                                                                                                                      • Generate a unique _id1 binding.

                                                                                                                                                                                      method generateUidIdentifier

                                                                                                                                                                                      generateUidIdentifier: (name?: string) => t.Identifier;
                                                                                                                                                                                      • Generate a unique identifier.

                                                                                                                                                                                      method getAllBindings

                                                                                                                                                                                      getAllBindings: (...kinds: string[]) => object;
                                                                                                                                                                                      • Walks the scope tree and gathers **all** bindings.

                                                                                                                                                                                      interface VisitNodeObject

                                                                                                                                                                                      interface VisitNodeObject<T> {}

                                                                                                                                                                                        method enter

                                                                                                                                                                                        enter: (path: NodePath<T>, state: any) => void;

                                                                                                                                                                                          method exit

                                                                                                                                                                                          exit: (path: NodePath<T>, state: any) => void;

                                                                                                                                                                                            interface Visitor

                                                                                                                                                                                            interface Visitor<S = Node> extends VisitNodeObject<Node> {}

                                                                                                                                                                                              property AnyTypeAnnotation

                                                                                                                                                                                              AnyTypeAnnotation?: VisitNode<S, t.AnyTypeAnnotation>;

                                                                                                                                                                                                property ArrayExpression

                                                                                                                                                                                                ArrayExpression?: VisitNode<S, t.ArrayExpression>;

                                                                                                                                                                                                  property ArrayPattern

                                                                                                                                                                                                  ArrayPattern?: VisitNode<S, t.ArrayPattern>;

                                                                                                                                                                                                    property ArrayTypeAnnotation

                                                                                                                                                                                                    ArrayTypeAnnotation?: VisitNode<S, t.ArrayTypeAnnotation>;

                                                                                                                                                                                                      property ArrowFunctionExpression

                                                                                                                                                                                                      ArrowFunctionExpression?: VisitNode<S, t.ArrowFunctionExpression>;

                                                                                                                                                                                                        property AssignmentExpression

                                                                                                                                                                                                        AssignmentExpression?: VisitNode<S, t.AssignmentExpression>;

                                                                                                                                                                                                          property AssignmentPattern

                                                                                                                                                                                                          AssignmentPattern?: VisitNode<S, t.AssignmentPattern>;

                                                                                                                                                                                                            property AwaitExpression

                                                                                                                                                                                                            AwaitExpression?: VisitNode<S, t.AwaitExpression>;

                                                                                                                                                                                                              property Binary

                                                                                                                                                                                                              Binary?: VisitNode<S, t.Binary>;

                                                                                                                                                                                                                property BinaryExpression

                                                                                                                                                                                                                BinaryExpression?: VisitNode<S, t.BinaryExpression>;

                                                                                                                                                                                                                  property BindExpression

                                                                                                                                                                                                                  BindExpression?: VisitNode<S, t.BindExpression>;

                                                                                                                                                                                                                    property Block

                                                                                                                                                                                                                    Block?: VisitNode<S, t.Block>;

                                                                                                                                                                                                                      property BlockParent

                                                                                                                                                                                                                      BlockParent?: VisitNode<S, t.BlockParent>;

                                                                                                                                                                                                                        property BlockStatement

                                                                                                                                                                                                                        BlockStatement?: VisitNode<S, t.BlockStatement>;

                                                                                                                                                                                                                          property BooleanLiteral

                                                                                                                                                                                                                          BooleanLiteral?: VisitNode<S, t.BooleanLiteral>;

                                                                                                                                                                                                                            property BooleanLiteralTypeAnnotation

                                                                                                                                                                                                                            BooleanLiteralTypeAnnotation?: VisitNode<S, t.BooleanLiteralTypeAnnotation>;

                                                                                                                                                                                                                              property BooleanTypeAnnotation

                                                                                                                                                                                                                              BooleanTypeAnnotation?: VisitNode<S, t.BooleanTypeAnnotation>;

                                                                                                                                                                                                                                property BreakStatement

                                                                                                                                                                                                                                BreakStatement?: VisitNode<S, t.BreakStatement>;

                                                                                                                                                                                                                                  property CallExpression

                                                                                                                                                                                                                                  CallExpression?: VisitNode<S, t.CallExpression>;

                                                                                                                                                                                                                                    property CatchClause

                                                                                                                                                                                                                                    CatchClause?: VisitNode<S, t.CatchClause>;

                                                                                                                                                                                                                                      property Class

                                                                                                                                                                                                                                      Class?: VisitNode<S, t.Class>;

                                                                                                                                                                                                                                        property ClassBody

                                                                                                                                                                                                                                        ClassBody?: VisitNode<S, t.ClassBody>;

                                                                                                                                                                                                                                          property ClassDeclaration

                                                                                                                                                                                                                                          ClassDeclaration?: VisitNode<S, t.ClassDeclaration>;

                                                                                                                                                                                                                                            property ClassExpression

                                                                                                                                                                                                                                            ClassExpression?: VisitNode<S, t.ClassExpression>;

                                                                                                                                                                                                                                              property ClassImplements

                                                                                                                                                                                                                                              ClassImplements?: VisitNode<S, t.ClassImplements>;

                                                                                                                                                                                                                                                property ClassMethod

                                                                                                                                                                                                                                                ClassMethod?: VisitNode<S, t.ClassMethod>;

                                                                                                                                                                                                                                                  property ClassProperty

                                                                                                                                                                                                                                                  ClassProperty?: VisitNode<S, t.ClassProperty>;

                                                                                                                                                                                                                                                    property CompletionStatement

                                                                                                                                                                                                                                                    CompletionStatement?: VisitNode<S, t.CompletionStatement>;

                                                                                                                                                                                                                                                      property Conditional

                                                                                                                                                                                                                                                      Conditional?: VisitNode<S, t.Conditional>;

                                                                                                                                                                                                                                                        property ConditionalExpression

                                                                                                                                                                                                                                                        ConditionalExpression?: VisitNode<S, t.ConditionalExpression>;

                                                                                                                                                                                                                                                          property ContinueStatement

                                                                                                                                                                                                                                                          ContinueStatement?: VisitNode<S, t.ContinueStatement>;

                                                                                                                                                                                                                                                            property DebuggerStatement

                                                                                                                                                                                                                                                            DebuggerStatement?: VisitNode<S, t.DebuggerStatement>;

                                                                                                                                                                                                                                                              property Declaration

                                                                                                                                                                                                                                                              Declaration?: VisitNode<S, t.Declaration>;

                                                                                                                                                                                                                                                                property DeclareClass

                                                                                                                                                                                                                                                                DeclareClass?: VisitNode<S, t.DeclareClass>;

                                                                                                                                                                                                                                                                  property DeclareFunction

                                                                                                                                                                                                                                                                  DeclareFunction?: VisitNode<S, t.DeclareFunction>;

                                                                                                                                                                                                                                                                    property DeclareInterface

                                                                                                                                                                                                                                                                    DeclareInterface?: VisitNode<S, t.DeclareInterface>;

                                                                                                                                                                                                                                                                      property DeclareModule

                                                                                                                                                                                                                                                                      DeclareModule?: VisitNode<S, t.DeclareModule>;

                                                                                                                                                                                                                                                                        property DeclareTypeAlias

                                                                                                                                                                                                                                                                        DeclareTypeAlias?: VisitNode<S, t.DeclareTypeAlias>;

                                                                                                                                                                                                                                                                          property DeclareVariable

                                                                                                                                                                                                                                                                          DeclareVariable?: VisitNode<S, t.DeclareVariable>;

                                                                                                                                                                                                                                                                            property Decorator

                                                                                                                                                                                                                                                                            Decorator?: VisitNode<S, t.Decorator>;

                                                                                                                                                                                                                                                                              property Directive

                                                                                                                                                                                                                                                                              Directive?: VisitNode<S, t.Directive>;

                                                                                                                                                                                                                                                                                property DirectiveLiteral

                                                                                                                                                                                                                                                                                DirectiveLiteral?: VisitNode<S, t.DirectiveLiteral>;

                                                                                                                                                                                                                                                                                  property DoExpression

                                                                                                                                                                                                                                                                                  DoExpression?: VisitNode<S, t.DoExpression>;

                                                                                                                                                                                                                                                                                    property DoWhileStatement

                                                                                                                                                                                                                                                                                    DoWhileStatement?: VisitNode<S, t.DoWhileStatement>;

                                                                                                                                                                                                                                                                                      property EmptyStatement

                                                                                                                                                                                                                                                                                      EmptyStatement?: VisitNode<S, t.EmptyStatement>;

                                                                                                                                                                                                                                                                                        property ExistentialTypeParam

                                                                                                                                                                                                                                                                                        ExistentialTypeParam?: VisitNode<S, t.ExistentialTypeParam>;

                                                                                                                                                                                                                                                                                          property ExportAllDeclaration

                                                                                                                                                                                                                                                                                          ExportAllDeclaration?: VisitNode<S, t.ExportAllDeclaration>;

                                                                                                                                                                                                                                                                                            property ExportDeclaration

                                                                                                                                                                                                                                                                                            ExportDeclaration?: VisitNode<S, t.ExportDeclaration>;

                                                                                                                                                                                                                                                                                              property ExportDefaultDeclaration

                                                                                                                                                                                                                                                                                              ExportDefaultDeclaration?: VisitNode<S, t.ExportDefaultDeclaration>;

                                                                                                                                                                                                                                                                                                property ExportDefaultSpecifier

                                                                                                                                                                                                                                                                                                ExportDefaultSpecifier?: VisitNode<S, t.ExportDefaultSpecifier>;

                                                                                                                                                                                                                                                                                                  property ExportNamedDeclaration

                                                                                                                                                                                                                                                                                                  ExportNamedDeclaration?: VisitNode<S, t.ExportNamedDeclaration>;

                                                                                                                                                                                                                                                                                                    property ExportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                    ExportNamespaceSpecifier?: VisitNode<S, t.ExportNamespaceSpecifier>;

                                                                                                                                                                                                                                                                                                      property ExportSpecifier

                                                                                                                                                                                                                                                                                                      ExportSpecifier?: VisitNode<S, t.ExportSpecifier>;

                                                                                                                                                                                                                                                                                                        property Expression

                                                                                                                                                                                                                                                                                                        Expression?: VisitNode<S, t.Expression>;

                                                                                                                                                                                                                                                                                                          property ExpressionStatement

                                                                                                                                                                                                                                                                                                          ExpressionStatement?: VisitNode<S, t.ExpressionStatement>;

                                                                                                                                                                                                                                                                                                            property ExpressionWrapper

                                                                                                                                                                                                                                                                                                            ExpressionWrapper?: VisitNode<S, t.ExpressionWrapper>;

                                                                                                                                                                                                                                                                                                              property File

                                                                                                                                                                                                                                                                                                              File?: VisitNode<S, t.File>;

                                                                                                                                                                                                                                                                                                                property Flow

                                                                                                                                                                                                                                                                                                                Flow?: VisitNode<S, t.Flow>;

                                                                                                                                                                                                                                                                                                                  property FlowBaseAnnotation

                                                                                                                                                                                                                                                                                                                  FlowBaseAnnotation?: VisitNode<S, t.FlowBaseAnnotation>;

                                                                                                                                                                                                                                                                                                                    property FlowDeclaration

                                                                                                                                                                                                                                                                                                                    FlowDeclaration?: VisitNode<S, t.FlowDeclaration>;

                                                                                                                                                                                                                                                                                                                      property For

                                                                                                                                                                                                                                                                                                                      For?: VisitNode<S, t.For>;

                                                                                                                                                                                                                                                                                                                        property ForInStatement

                                                                                                                                                                                                                                                                                                                        ForInStatement?: VisitNode<S, t.ForInStatement>;

                                                                                                                                                                                                                                                                                                                          property ForOfStatement

                                                                                                                                                                                                                                                                                                                          ForOfStatement?: VisitNode<S, t.ForOfStatement>;

                                                                                                                                                                                                                                                                                                                            property ForStatement

                                                                                                                                                                                                                                                                                                                            ForStatement?: VisitNode<S, t.ForStatement>;

                                                                                                                                                                                                                                                                                                                              property ForXStatement

                                                                                                                                                                                                                                                                                                                              ForXStatement?: VisitNode<S, t.ForXStatement>;

                                                                                                                                                                                                                                                                                                                                property Function

                                                                                                                                                                                                                                                                                                                                Function?: VisitNode<S, t.Function>;

                                                                                                                                                                                                                                                                                                                                  property FunctionDeclaration

                                                                                                                                                                                                                                                                                                                                  FunctionDeclaration?: VisitNode<S, t.FunctionDeclaration>;

                                                                                                                                                                                                                                                                                                                                    property FunctionExpression

                                                                                                                                                                                                                                                                                                                                    FunctionExpression?: VisitNode<S, t.FunctionExpression>;

                                                                                                                                                                                                                                                                                                                                      property FunctionParent

                                                                                                                                                                                                                                                                                                                                      FunctionParent?: VisitNode<S, t.FunctionParent>;

                                                                                                                                                                                                                                                                                                                                        property FunctionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                        FunctionTypeAnnotation?: VisitNode<S, t.FunctionTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                          property FunctionTypeParam

                                                                                                                                                                                                                                                                                                                                          FunctionTypeParam?: VisitNode<S, t.FunctionTypeParam>;

                                                                                                                                                                                                                                                                                                                                            property GenericTypeAnnotation

                                                                                                                                                                                                                                                                                                                                            GenericTypeAnnotation?: VisitNode<S, t.GenericTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                              property Identifier

                                                                                                                                                                                                                                                                                                                                              Identifier?: VisitNode<S, t.Identifier>;

                                                                                                                                                                                                                                                                                                                                                property IfStatement

                                                                                                                                                                                                                                                                                                                                                IfStatement?: VisitNode<S, t.IfStatement>;

                                                                                                                                                                                                                                                                                                                                                  property Immutable

                                                                                                                                                                                                                                                                                                                                                  Immutable?: VisitNode<S, t.Immutable>;

                                                                                                                                                                                                                                                                                                                                                    property ImportDeclaration

                                                                                                                                                                                                                                                                                                                                                    ImportDeclaration?: VisitNode<S, t.ImportDeclaration>;

                                                                                                                                                                                                                                                                                                                                                      property ImportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                      ImportDefaultSpecifier?: VisitNode<S, t.ImportDefaultSpecifier>;

                                                                                                                                                                                                                                                                                                                                                        property ImportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                        ImportNamespaceSpecifier?: VisitNode<S, t.ImportNamespaceSpecifier>;

                                                                                                                                                                                                                                                                                                                                                          property ImportSpecifier

                                                                                                                                                                                                                                                                                                                                                          ImportSpecifier?: VisitNode<S, t.ImportSpecifier>;

                                                                                                                                                                                                                                                                                                                                                            property InterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                            InterfaceDeclaration?: VisitNode<S, t.InterfaceDeclaration>;

                                                                                                                                                                                                                                                                                                                                                              property InterfaceExtends

                                                                                                                                                                                                                                                                                                                                                              InterfaceExtends?: VisitNode<S, t.InterfaceExtends>;

                                                                                                                                                                                                                                                                                                                                                                property IntersectionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                IntersectionTypeAnnotation?: VisitNode<S, t.IntersectionTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                  property JSX

                                                                                                                                                                                                                                                                                                                                                                  JSX?: VisitNode<S, t.JSX>;

                                                                                                                                                                                                                                                                                                                                                                    property JSXAttribute

                                                                                                                                                                                                                                                                                                                                                                    JSXAttribute?: VisitNode<S, t.JSXAttribute>;

                                                                                                                                                                                                                                                                                                                                                                      property JSXClosingElement

                                                                                                                                                                                                                                                                                                                                                                      JSXClosingElement?: VisitNode<S, t.JSXClosingElement>;

                                                                                                                                                                                                                                                                                                                                                                        property JSXElement

                                                                                                                                                                                                                                                                                                                                                                        JSXElement?: VisitNode<S, t.JSXElement>;

                                                                                                                                                                                                                                                                                                                                                                          property JSXEmptyExpression

                                                                                                                                                                                                                                                                                                                                                                          JSXEmptyExpression?: VisitNode<S, t.JSXEmptyExpression>;

                                                                                                                                                                                                                                                                                                                                                                            property JSXExpressionContainer

                                                                                                                                                                                                                                                                                                                                                                            JSXExpressionContainer?: VisitNode<S, t.JSXExpressionContainer>;

                                                                                                                                                                                                                                                                                                                                                                              property JSXIdentifier

                                                                                                                                                                                                                                                                                                                                                                              JSXIdentifier?: VisitNode<S, t.JSXIdentifier>;

                                                                                                                                                                                                                                                                                                                                                                                property JSXMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                JSXMemberExpression?: VisitNode<S, t.JSXMemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                  property JSXNamespacedName

                                                                                                                                                                                                                                                                                                                                                                                  JSXNamespacedName?: VisitNode<S, t.JSXNamespacedName>;

                                                                                                                                                                                                                                                                                                                                                                                    property JSXOpeningElement

                                                                                                                                                                                                                                                                                                                                                                                    JSXOpeningElement?: VisitNode<S, t.JSXOpeningElement>;

                                                                                                                                                                                                                                                                                                                                                                                      property JSXSpreadAttribute

                                                                                                                                                                                                                                                                                                                                                                                      JSXSpreadAttribute?: VisitNode<S, t.JSXSpreadAttribute>;

                                                                                                                                                                                                                                                                                                                                                                                        property JSXText

                                                                                                                                                                                                                                                                                                                                                                                        JSXText?: VisitNode<S, t.JSXText>;

                                                                                                                                                                                                                                                                                                                                                                                          property LabeledStatement

                                                                                                                                                                                                                                                                                                                                                                                          LabeledStatement?: VisitNode<S, t.LabeledStatement>;

                                                                                                                                                                                                                                                                                                                                                                                            property Literal

                                                                                                                                                                                                                                                                                                                                                                                            Literal?: VisitNode<S, t.Literal>;

                                                                                                                                                                                                                                                                                                                                                                                              property LogicalExpression

                                                                                                                                                                                                                                                                                                                                                                                              LogicalExpression?: VisitNode<S, t.LogicalExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                property Loop

                                                                                                                                                                                                                                                                                                                                                                                                Loop?: VisitNode<S, t.Loop>;

                                                                                                                                                                                                                                                                                                                                                                                                  property LVal

                                                                                                                                                                                                                                                                                                                                                                                                  LVal?: VisitNode<S, t.LVal>;

                                                                                                                                                                                                                                                                                                                                                                                                    property MemberExpression

                                                                                                                                                                                                                                                                                                                                                                                                    MemberExpression?: VisitNode<S, t.MemberExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                      property MetaProperty

                                                                                                                                                                                                                                                                                                                                                                                                      MetaProperty?: VisitNode<S, t.MetaProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                        property Method

                                                                                                                                                                                                                                                                                                                                                                                                        Method?: VisitNode<S, t.Method>;

                                                                                                                                                                                                                                                                                                                                                                                                          property MixedTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                          MixedTypeAnnotation?: VisitNode<S, t.MixedTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                            property ModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                            ModuleDeclaration?: VisitNode<S, t.ModuleDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                              property ModuleSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                              ModuleSpecifier?: VisitNode<S, t.ModuleSpecifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                property NewExpression

                                                                                                                                                                                                                                                                                                                                                                                                                NewExpression?: VisitNode<S, t.NewExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                  property Noop

                                                                                                                                                                                                                                                                                                                                                                                                                  Noop?: VisitNode<S, t.Noop>;

                                                                                                                                                                                                                                                                                                                                                                                                                    property NullableTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                    NullableTypeAnnotation?: VisitNode<S, t.NullableTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                      property NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                      NullLiteral?: VisitNode<S, t.NullLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                        property NullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                        NullLiteralTypeAnnotation?: VisitNode<S, t.NullLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                          property NumberTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                          NumberTypeAnnotation?: VisitNode<S, t.NumberTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                            property NumericLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                            NumericLiteral?: VisitNode<S, t.NumericLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                              property NumericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                              NumericLiteralTypeAnnotation?: VisitNode<S, t.NumericLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                property ObjectExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                ObjectExpression?: VisitNode<S, t.ObjectExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                  property ObjectMember

                                                                                                                                                                                                                                                                                                                                                                                                                                  ObjectMember?: VisitNode<S, t.ObjectMember>;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property ObjectMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                    ObjectMethod?: VisitNode<S, t.ObjectMethod>;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property ObjectPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                      ObjectPattern?: VisitNode<S, t.ObjectPattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property ObjectProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                        ObjectProperty?: VisitNode<S, t.ObjectProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                          property ObjectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                          ObjectTypeAnnotation?: VisitNode<S, t.ObjectTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property ObjectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                            ObjectTypeCallProperty?: VisitNode<S, t.ObjectTypeCallProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property ObjectTypeIndexer

                                                                                                                                                                                                                                                                                                                                                                                                                                              ObjectTypeIndexer?: VisitNode<S, t.ObjectTypeIndexer>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property ObjectTypeProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                ObjectTypeProperty?: VisitNode<S, t.ObjectTypeProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property ParenthesizedExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ParenthesizedExpression?: VisitNode<S, t.ParenthesizedExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Pattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Pattern?: VisitNode<S, t.Pattern>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Program?: VisitNode<S, t.Program>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Property

                                                                                                                                                                                                                                                                                                                                                                                                                                                        Property?: VisitNode<S, t.Property>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property Pureish

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Pureish?: VisitNode<S, t.Pureish>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property QualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                            QualifiedTypeIdentifier?: VisitNode<S, t.QualifiedTypeIdentifier>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property RegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                              RegExpLiteral?: VisitNode<S, t.RegExpLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property RestElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                RestElement?: VisitNode<S, t.RestElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property RestProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  RestProperty?: VisitNode<S, t.RestProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ReturnStatement?: VisitNode<S, t.ReturnStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property Scopable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Scopable?: VisitNode<S, t.Scopable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Scope

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Scope?: VisitNode<S, t.Scopable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property SequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SequenceExpression?: VisitNode<S, t.SequenceExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property SpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SpreadElement?: VisitNode<S, t.SpreadElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property SpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SpreadProperty?: VisitNode<S, t.SpreadProperty>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Statement?: VisitNode<S, t.Statement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  StringLiteral?: VisitNode<S, t.StringLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property StringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StringLiteralTypeAnnotation?: VisitNode<S, t.StringLiteralTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property StringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StringTypeAnnotation?: VisitNode<S, t.StringTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property Super

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Super?: VisitNode<S, t.Super>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property SwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SwitchCase?: VisitNode<S, t.SwitchCase>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property SwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            SwitchStatement?: VisitNode<S, t.SwitchStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property TaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TaggedTemplateExpression?: VisitNode<S, t.TaggedTemplateExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property TemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TemplateElement?: VisitNode<S, t.TemplateElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property TemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TemplateLiteral?: VisitNode<S, t.TemplateLiteral>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property Terminatorless

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Terminatorless?: VisitNode<S, t.Terminatorless>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ThisExpression?: VisitNode<S, t.ThisExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ThisTypeAnnotation?: VisitNode<S, t.ThisTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property ThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ThrowStatement?: VisitNode<S, t.ThrowStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property TryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TryStatement?: VisitNode<S, t.TryStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property TupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TupleTypeAnnotation?: VisitNode<S, t.TupleTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property TypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TypeAlias?: VisitNode<S, t.TypeAlias>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property TypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TypeAnnotation?: VisitNode<S, t.TypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property TypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    TypeCastExpression?: VisitNode<S, t.TypeCastExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property TypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TypeofTypeAnnotation?: VisitNode<S, t.TypeofTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property TypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TypeParameterDeclaration?: VisitNode<S, t.TypeParameterDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property TypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          TypeParameterInstantiation?: VisitNode<S, t.TypeParameterInstantiation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property UnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            UnaryExpression?: VisitNode<S, t.UnaryExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property UnaryLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UnaryLike?: VisitNode<S, t.UnaryLike>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property UnionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UnionTypeAnnotation?: VisitNode<S, t.UnionTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property UpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UpdateExpression?: VisitNode<S, t.UpdateExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property UserWhitespacable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    UserWhitespacable?: VisitNode<S, t.UserWhitespacable>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property VariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      VariableDeclaration?: VisitNode<S, t.VariableDeclaration>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property VariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        VariableDeclarator?: VisitNode<S, t.VariableDeclarator>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property VoidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          VoidTypeAnnotation?: VisitNode<S, t.VoidTypeAnnotation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property While

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            While?: VisitNode<S, t.While>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property WhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              WhileStatement?: VisitNode<S, t.WhileStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property WithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WithStatement?: VisitNode<S, t.WithStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property YieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  YieldExpression?: VisitNode<S, t.YieldExpression>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node = t.Node;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VisitNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type VisitNode<T, P> = VisitNodeFunction<T, P> | VisitNodeObject<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VisitNodeFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type VisitNodeFunction<T, P> = (this: T, path: NodePath<P>, state: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace matcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          module 'matcher' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isMatch: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            input: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pattern: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: { caseSensitive: boolean }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace sw-precache

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'sw-precache' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function generate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                generate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options: SWConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (err?: Error, fileContents?: string) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function write

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  write: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  filepath: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options: SWConfig,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  callback: (err?: Error) => void
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SWConfig

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SWConfig {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property cacheId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cacheId?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property directoryIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directoryIndex?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property dynamicUrlToDependencies

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          dynamicUrlToDependencies?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [property: string]: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property handleFetch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handleFetch?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ignoreUrlParametersMatching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ignoreUrlParametersMatching?: RegExp[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property importScripts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                importScripts?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  logger?: Function;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property maximumFileSizeToCacheInBytes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    maximumFileSizeToCacheInBytes?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property navigateFallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      navigateFallback?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property navigateFallbackWhitelist

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        navigateFallbackWhitelist?: RegExp[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property replacePrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          replacePrefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property runtimeCaching

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            runtimeCaching?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            urlPattern: RegExp;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handler: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options?: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            cache: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            maxEntries: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property staticFileGlobs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              staticFileGlobs?: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property stripPrefix

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                stripPrefix?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property templateFilePath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  templateFilePath?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property verbose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    verbose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace vinyl-fs-fake

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      module 'vinyl-fs-fake' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function src

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        src: (files: File[], options?: Options) => stream.Readable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface File

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface File {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property contents

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            contents: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Options {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property cwdbase

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  cwdbase: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace whatwg-url

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    module 'whatwg-url' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function parseURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parseURL: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      input: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      options?: { baseURL?: URL; encodingOverride?: string }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => URL | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface URL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface URL {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property cannotBeABaseURL

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cannotBeABaseURL: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fragment: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property host

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              host: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property password

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                password: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property port

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    port: number | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      query: string | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property scheme

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scheme: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property username

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          username: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (17)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (65)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (11)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.


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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/polymer-build.

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