@glimmer/syntax

  • Version 0.80.0
  • Published
  • 4.16 MB
  • 4 dependencies
  • MIT license

Install

npm i @glimmer/syntax
yarn add @glimmer/syntax
pnpm add @glimmer/syntax

Overview

Overview not available.

Index

Variables

Functions

Classes

Interfaces

Type Aliases

Namespaces

Variables

variable builders

const builders: {
mustache: typeof buildMustache;
block: typeof buildBlock;
partial: typeof buildPartial;
comment: typeof buildComment;
mustacheComment: typeof buildMustacheComment;
element: typeof buildElement;
elementModifier: typeof buildElementModifier;
attr: typeof buildAttr;
text: typeof buildText;
sexpr: typeof buildSexpr;
concat: typeof buildConcat;
hash: typeof buildHash;
pair: typeof buildPair;
literal: typeof buildLiteral;
program: typeof buildProgram;
blockItself: typeof buildBlockItself;
template: typeof buildTemplate;
loc: typeof buildLoc;
pos: typeof buildPosition;
path: typeof buildPath;
fullPath: typeof buildCleanPath;
head: typeof buildHeadFromString;
at: typeof buildAtName;
var: typeof buildVar;
this: typeof buildThis;
blockName: typeof buildNamedBlockName;
string: (value: string) => ASTv1.StringLiteral;
boolean: (value: boolean) => ASTv1.BooleanLiteral;
number: (value: number) => ASTv1.NumberLiteral;
undefined(): ASTv1.UndefinedLiteral;
null(): ASTv1.NullLiteral;
};

    variable KEYWORDS_TYPES

    const KEYWORDS_TYPES: { [key: string]: KeywordType[] };
    • This includes the full list of keywords currently in use in the template language, and where their valid usages are.

    Functions

    function cannotRemoveNode

    cannotRemoveNode: (
    node: ASTv1.Node,
    parent: ASTv1.Node,
    key: string
    ) => TraversalError;

      function cannotReplaceNode

      cannotReplaceNode: (
      node: ASTv1.Node,
      parent: ASTv1.Node,
      key: string
      ) => TraversalError;

        function generateSyntaxError

        generateSyntaxError: (
        message: string,
        location: SourceSpan
        ) => GlimmerSyntaxError;

          function getTemplateLocals

          getTemplateLocals: (
          html: string,
          options?: GetTemplateLocalsOptions
          ) => string[];
          • Parses and traverses a given handlebars html template to extract all template locals referenced that could possible come from the praent scope. Can exclude known keywords optionally.

          function hasSpan

          hasSpan: (span: MaybeHasSourceSpan) => span is HasSourceSpan;

            function isKeyword

            isKeyword: (word: string) => boolean;

              function loc

              loc: (span: HasSourceSpan) => SourceSpan;

                function maybeLoc

                maybeLoc: (location: MaybeHasSourceSpan, fallback: SourceSpan) => SourceSpan;

                  function node

                  node: {
                  (): {
                  fields<Fields extends object>(): NodeConstructor<Fields & BaseNodeFields>;
                  };
                  <T extends string>(name: T): {
                  fields<Fields extends object>(): TypedNodeConstructor<
                  T,
                  Fields & BaseNodeFields
                  >;
                  };
                  };
                  • This is a convenience function for creating ASTv2 nodes, with an optional name and the node's options.

                    export class HtmlText extends node('HtmlText').fields<{ chars: string }>() {}

                    This creates a new ASTv2 node with the name 'HtmlText' and one field chars: string (in addition to a loc: SourceOffsets field, which all nodes have).

                    export class Args extends node().fields<{
                    positional: PositionalArguments;
                    named: NamedArguments
                    }>() {}

                    This creates a new un-named ASTv2 node with two fields (positional: Positional and `named: Named, in addition to the generic loc: SourceOffsets` field).

                    Once you create a node using node, it is instantiated with all of its fields (including loc):

                    new HtmlText({ loc: offsets, chars: someString });

                  function normalize

                  normalize: (
                  source: Source,
                  options?: PrecompileOptions
                  ) => [ast: ASTv2.Template, locals: string[]];

                    function preprocess

                    preprocess: (
                    input: string | Source | HBS.Program,
                    options?: PreprocessOptions
                    ) => ASTv1.Template;

                      function print

                      print: (ast: ASTv1.Node, options?: PrinterOptions) => string;

                        function sortByLoc

                        sortByLoc: (a: ASTv1.Node, b: ASTv1.Node) => -1 | 0 | 1;

                          function traverse

                          traverse: (node: ASTv1.Node, visitor: NodeVisitor) => void;

                            Classes

                            class BlockSymbolTable

                            class BlockSymbolTable extends SymbolTable {}

                              constructor

                              constructor(parent: SymbolTable, symbols: string[], slots: number[]);

                                property locals

                                readonly locals: string[];

                                  property slots

                                  slots: number[];

                                    property symbols

                                    symbols: string[];

                                      method allocate

                                      allocate: (identifier: string) => number;

                                        method allocateBlock

                                        allocateBlock: (name: string) => number;

                                          method allocateFree

                                          allocateFree: (name: string, resolution: ASTv2.FreeVarResolution) => number;

                                            method allocateNamed

                                            allocateNamed: (name: string) => number;

                                              method get

                                              get: (name: string) => [number, boolean];

                                                method getEvalInfo

                                                getEvalInfo: () => any;

                                                  method getLocalsMap

                                                  getLocalsMap: () => any;

                                                    method has

                                                    has: (name: string) => boolean;

                                                      method setHasEval

                                                      setHasEval: () => void;

                                                        class Path

                                                        class Walker {}

                                                          constructor

                                                          constructor(order?: {});

                                                            property order

                                                            order?: {};

                                                              property stack

                                                              stack: unknown[];

                                                                method children

                                                                children: <N extends ASTv1.Node>(
                                                                node: N & ASTv1.Node,
                                                                callback: NodeCallback<N & ASTv1.Node>
                                                                ) => void;

                                                                  method visit

                                                                  visit: <N extends ASTv1.Node>(node: any, callback: NodeCallback<N>) => void;

                                                                    class ProgramSymbolTable

                                                                    class ProgramSymbolTable extends SymbolTable {}

                                                                      constructor

                                                                      constructor(
                                                                      templateLocals: string[],
                                                                      customizeComponentName: (input: string) => string
                                                                      );

                                                                        property hasEval

                                                                        readonly hasEval: boolean;

                                                                          property symbols

                                                                          symbols: string[];

                                                                            property upvars

                                                                            upvars: string[];

                                                                              method allocate

                                                                              allocate: (identifier: string) => number;

                                                                                method allocateBlock

                                                                                allocateBlock: (name: string) => number;

                                                                                  method allocateFree

                                                                                  allocateFree: (name: string, resolution: ASTv2.FreeVarResolution) => number;

                                                                                    method allocateNamed

                                                                                    allocateNamed: (name: string) => number;

                                                                                      method get

                                                                                      get: (name: string) => [number, boolean];

                                                                                        method getEvalInfo

                                                                                        getEvalInfo: () => any;

                                                                                          method getLocalsMap

                                                                                          getLocalsMap: () => any;

                                                                                            method getUsedTemplateLocals

                                                                                            getUsedTemplateLocals: () => string[];

                                                                                              method has

                                                                                              has: (name: string) => boolean;

                                                                                                method setHasEval

                                                                                                setHasEval: () => void;

                                                                                                  class Source

                                                                                                  class Source {}

                                                                                                    constructor

                                                                                                    constructor(source: string, module?: string);

                                                                                                      property module

                                                                                                      readonly module: string;

                                                                                                        property source

                                                                                                        readonly source: string;

                                                                                                          method charPosFor

                                                                                                          charPosFor: (position: SourcePosition) => number | null;

                                                                                                            method check

                                                                                                            check: (offset: number) => boolean;
                                                                                                            • Validate that the character offset represents a position in the source string.

                                                                                                            method hbsPosFor

                                                                                                            hbsPosFor: (offset: number) => any;

                                                                                                              method offsetFor

                                                                                                              offsetFor: (line: number, column: number) => SourceOffset;

                                                                                                                method slice

                                                                                                                slice: (start: number, end: number) => string;

                                                                                                                  method spanFor

                                                                                                                  spanFor: ({ start, end }: Readonly<SourceLocation>) => SourceSpan;

                                                                                                                    class SourceSlice

                                                                                                                    class SourceSlice<Chars extends string = string> {}

                                                                                                                      constructor

                                                                                                                      constructor(options: { loc: SourceSpan; chars: Chars });

                                                                                                                        property chars

                                                                                                                        readonly chars: string;

                                                                                                                          property loc

                                                                                                                          readonly loc: SourceSpan;

                                                                                                                            method getString

                                                                                                                            getString: () => string;

                                                                                                                              method load

                                                                                                                              static load: (
                                                                                                                              source: Source,
                                                                                                                              slice: SerializedSourceSlice<string>
                                                                                                                              ) => SourceSlice;

                                                                                                                                method serialize

                                                                                                                                serialize: () => SerializedSourceSlice<Chars>;

                                                                                                                                  method synthetic

                                                                                                                                  static synthetic: <S extends string>(chars: S) => SourceSlice<S>;

                                                                                                                                    class SourceSpan

                                                                                                                                    class SourceSpan implements SourceLocation {}
                                                                                                                                    • A SourceSpan object represents a span of characters inside of a template source.

                                                                                                                                      There are three kinds of SourceSpan objects:

                                                                                                                                      - ConcreteSourceSpan, which contains byte offsets - LazySourceSpan, which contains SourceLocations from the Handlebars AST, which can be converted to byte offsets on demand. - InvisibleSourceSpan, which represent source strings that aren't present in the source, because: - they were created synthetically - their location is nonsensical (the span is broken) - they represent nothing in the source (this currently happens only when a bug in the upstream Handlebars parser fails to assign a location to empty blocks)

                                                                                                                                      At a high level, all SourceSpan objects provide:

                                                                                                                                      - byte offsets - source in column and line format

                                                                                                                                      And you can do these operations on SourceSpans:

                                                                                                                                      - collapse it to a SourceSpan representing its starting or ending position - slice out some characters, optionally skipping some characters at the beginning or end - create a new SourceSpan with a different starting or ending offset

                                                                                                                                      All SourceSpan objects implement SourceLocation, for compatibility. All SourceSpan objects have a toJSON that emits SourceLocation, also for compatibility.

                                                                                                                                      For compatibility, subclasses of AbstractSourceSpan must implement locDidUpdate, which happens when an AST plugin attempts to modify the start or end of a span directly.

                                                                                                                                      The goal is to avoid creating any problems for use-cases like AST Explorer.

                                                                                                                                    constructor

                                                                                                                                    constructor(data: SpanData & AnySpan);

                                                                                                                                      property end

                                                                                                                                      end: SourcePosition;
                                                                                                                                      • For compatibility with SourceLocation in AST plugins

                                                                                                                                        Deprecated

                                                                                                                                        use endPosition instead

                                                                                                                                      property endPosition

                                                                                                                                      readonly endPosition: SourcePosition;
                                                                                                                                      • Get the ending SourcePosition for this SourceSpan, lazily computing it if needed.

                                                                                                                                      property isInvisible

                                                                                                                                      readonly isInvisible: boolean;

                                                                                                                                        property loc

                                                                                                                                        readonly loc: SourceLocation;

                                                                                                                                          property module

                                                                                                                                          readonly module: string;

                                                                                                                                            property NON_EXISTENT

                                                                                                                                            static readonly NON_EXISTENT: SourceSpan;

                                                                                                                                              property source

                                                                                                                                              readonly source: string;
                                                                                                                                              • For compatibility with SourceLocation in AST plugins

                                                                                                                                                Deprecated

                                                                                                                                                use module instead

                                                                                                                                              property start

                                                                                                                                              start: SourcePosition;
                                                                                                                                              • For compatibility with SourceLocation in AST plugins

                                                                                                                                                Deprecated

                                                                                                                                                use startPosition instead

                                                                                                                                              property startPosition

                                                                                                                                              readonly startPosition: SourcePosition;
                                                                                                                                              • Get the starting SourcePosition for this SourceSpan, lazily computing it if needed.

                                                                                                                                              method asString

                                                                                                                                              asString: () => string;

                                                                                                                                                method broken

                                                                                                                                                static broken: (pos?: SourceLocation) => SourceSpan;

                                                                                                                                                  method collapse

                                                                                                                                                  collapse: (where: 'start' | 'end') => SourceSpan;

                                                                                                                                                    method extend

                                                                                                                                                    extend: (other: SourceSpan) => SourceSpan;

                                                                                                                                                      method forCharPositions

                                                                                                                                                      static forCharPositions: (
                                                                                                                                                      source: Source,
                                                                                                                                                      startPos: number,
                                                                                                                                                      endPos: number
                                                                                                                                                      ) => SourceSpan;

                                                                                                                                                        method forHbsLoc

                                                                                                                                                        static forHbsLoc: (source: Source, loc: SourceLocation) => SourceSpan;

                                                                                                                                                          method getEnd

                                                                                                                                                          getEnd: () => SourceOffset;

                                                                                                                                                            method getStart

                                                                                                                                                            getStart: () => SourceOffset;

                                                                                                                                                              method load

                                                                                                                                                              static load: (source: Source, serialized: SerializedSourceSpan) => SourceSpan;

                                                                                                                                                                method serialize

                                                                                                                                                                serialize: () => SerializedSourceSpan;

                                                                                                                                                                  method slice

                                                                                                                                                                  slice: ({
                                                                                                                                                                  skipStart,
                                                                                                                                                                  skipEnd,
                                                                                                                                                                  }: {
                                                                                                                                                                  skipStart?: number;
                                                                                                                                                                  skipEnd?: number;
                                                                                                                                                                  }) => SourceSpan;

                                                                                                                                                                    method sliceEndChars

                                                                                                                                                                    sliceEndChars: ({
                                                                                                                                                                    skipEnd,
                                                                                                                                                                    chars,
                                                                                                                                                                    }: {
                                                                                                                                                                    skipEnd?: number;
                                                                                                                                                                    chars: number;
                                                                                                                                                                    }) => SourceSpan;

                                                                                                                                                                      method sliceStartChars

                                                                                                                                                                      sliceStartChars: ({
                                                                                                                                                                      skipStart,
                                                                                                                                                                      chars,
                                                                                                                                                                      }: {
                                                                                                                                                                      skipStart?: number;
                                                                                                                                                                      chars: number;
                                                                                                                                                                      }) => SourceSpan;

                                                                                                                                                                        method synthetic

                                                                                                                                                                        static synthetic: (chars: string) => SourceSpan;

                                                                                                                                                                          method toJSON

                                                                                                                                                                          toJSON: () => SourceLocation;
                                                                                                                                                                          • Support converting ASTv1 nodes into a serialized format using JSON.stringify.

                                                                                                                                                                          method toSlice

                                                                                                                                                                          toSlice: (expected?: string) => SourceSlice;
                                                                                                                                                                          • Convert this SourceSpan into a SourceSlice. In debug mode, this method optionally checks that the byte offsets represented by this SourceSpan actually correspond to the expected string.

                                                                                                                                                                          method withEnd

                                                                                                                                                                          withEnd: (this: SourceSpan, other: SourceOffset) => SourceSpan;
                                                                                                                                                                          • Create a new span with the current span's beginning and a new ending.

                                                                                                                                                                          method withStart

                                                                                                                                                                          withStart: (other: SourceOffset) => SourceSpan;
                                                                                                                                                                          • Create a new span with the current span's end and a new beginning.

                                                                                                                                                                          class SpanList

                                                                                                                                                                          class SpanList {}

                                                                                                                                                                            constructor

                                                                                                                                                                            constructor(span?: SourceSpan[]);

                                                                                                                                                                              method add

                                                                                                                                                                              add: (offset: SourceSpan) => void;

                                                                                                                                                                                method getRangeOffset

                                                                                                                                                                                getRangeOffset: (fallback: SourceSpan) => SourceSpan;

                                                                                                                                                                                  method range

                                                                                                                                                                                  static range: {
                                                                                                                                                                                  (span: any): SourceSpan;
                                                                                                                                                                                  (span: HasSourceSpan[], fallback: SourceSpan): SourceSpan;
                                                                                                                                                                                  };

                                                                                                                                                                                    class SymbolTable

                                                                                                                                                                                    abstract class SymbolTable {}

                                                                                                                                                                                      method allocate

                                                                                                                                                                                      abstract allocate: (identifier: string) => number;

                                                                                                                                                                                        method allocateBlock

                                                                                                                                                                                        abstract allocateBlock: (name: string) => number;

                                                                                                                                                                                          method allocateFree

                                                                                                                                                                                          abstract allocateFree: (
                                                                                                                                                                                          name: string,
                                                                                                                                                                                          resolution: ASTv2.FreeVarResolution
                                                                                                                                                                                          ) => number;

                                                                                                                                                                                            method allocateNamed

                                                                                                                                                                                            abstract allocateNamed: (name: string) => number;

                                                                                                                                                                                              method child

                                                                                                                                                                                              child: (locals: string[]) => BlockSymbolTable;

                                                                                                                                                                                                method get

                                                                                                                                                                                                abstract get: (name: string) => [symbol: number, isRoot: boolean];

                                                                                                                                                                                                  method getEvalInfo

                                                                                                                                                                                                  abstract getEvalInfo: () => any;

                                                                                                                                                                                                    method getLocalsMap

                                                                                                                                                                                                    abstract getLocalsMap: () => any;

                                                                                                                                                                                                      method has

                                                                                                                                                                                                      abstract has: (name: string) => boolean;

                                                                                                                                                                                                        method setHasEval

                                                                                                                                                                                                        abstract setHasEval: () => void;

                                                                                                                                                                                                          method top

                                                                                                                                                                                                          static top: (
                                                                                                                                                                                                          locals: string[],
                                                                                                                                                                                                          customizeComponentName: (input: string) => string
                                                                                                                                                                                                          ) => ProgramSymbolTable;

                                                                                                                                                                                                            class Walker

                                                                                                                                                                                                            class Walker {}

                                                                                                                                                                                                              constructor

                                                                                                                                                                                                              constructor(order?: {});

                                                                                                                                                                                                                property order

                                                                                                                                                                                                                order?: {};

                                                                                                                                                                                                                  property stack

                                                                                                                                                                                                                  stack: unknown[];

                                                                                                                                                                                                                    method children

                                                                                                                                                                                                                    children: <N extends ASTv1.Node>(
                                                                                                                                                                                                                    node: N & ASTv1.Node,
                                                                                                                                                                                                                    callback: NodeCallback<N & ASTv1.Node>
                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                      method visit

                                                                                                                                                                                                                      visit: <N extends ASTv1.Node>(node: any, callback: NodeCallback<N>) => void;

                                                                                                                                                                                                                        class WalkerPath

                                                                                                                                                                                                                        class WalkerPath<N extends ASTv1.Node> {}

                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                          constructor(
                                                                                                                                                                                                                          node: ASTv1.Node,
                                                                                                                                                                                                                          parent?: WalkerPath<ASTv1.Node>,
                                                                                                                                                                                                                          parentKey?: string
                                                                                                                                                                                                                          );

                                                                                                                                                                                                                            property node

                                                                                                                                                                                                                            node: ASTv1.Node;

                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                              parent: WalkerPath<ASTv1.Node>;

                                                                                                                                                                                                                                property parentKey

                                                                                                                                                                                                                                parentKey: string;

                                                                                                                                                                                                                                  property parentNode

                                                                                                                                                                                                                                  readonly parentNode: ASTv1.Node;

                                                                                                                                                                                                                                    property scope

                                                                                                                                                                                                                                    scope: TransformScope;

                                                                                                                                                                                                                                      method parents

                                                                                                                                                                                                                                      parents: () => Iterable<WalkerPath<ASTv1.Node> | null>;

                                                                                                                                                                                                                                        Interfaces

                                                                                                                                                                                                                                        interface ASTPlugin

                                                                                                                                                                                                                                        interface ASTPlugin {}

                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                            property visitor

                                                                                                                                                                                                                                            visitor: NodeVisitor;

                                                                                                                                                                                                                                              interface ASTPluginBuilder

                                                                                                                                                                                                                                              interface ASTPluginBuilder<
                                                                                                                                                                                                                                              TEnv extends ASTPluginEnvironment = ASTPluginEnvironment
                                                                                                                                                                                                                                              > {}
                                                                                                                                                                                                                                              • ASTPlugins can make changes to the Glimmer template AST before compilation begins.

                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                              (env: TEnv): ASTPlugin;

                                                                                                                                                                                                                                                interface ASTPluginEnvironment

                                                                                                                                                                                                                                                interface ASTPluginEnvironment {}

                                                                                                                                                                                                                                                  property meta

                                                                                                                                                                                                                                                  meta?: object;

                                                                                                                                                                                                                                                    property syntax

                                                                                                                                                                                                                                                    syntax: Syntax;

                                                                                                                                                                                                                                                      interface GlimmerSyntaxError

                                                                                                                                                                                                                                                      interface GlimmerSyntaxError extends Error {}

                                                                                                                                                                                                                                                        property code

                                                                                                                                                                                                                                                        code: string | null;

                                                                                                                                                                                                                                                          property location

                                                                                                                                                                                                                                                          location: SourceSpan | null;

                                                                                                                                                                                                                                                            interface PrecompileOptions

                                                                                                                                                                                                                                                            interface PrecompileOptions extends PreprocessOptions {}

                                                                                                                                                                                                                                                              property id

                                                                                                                                                                                                                                                              id?: TemplateIdFn;

                                                                                                                                                                                                                                                                method customizeComponentName

                                                                                                                                                                                                                                                                customizeComponentName: (input: string) => string;

                                                                                                                                                                                                                                                                  interface PreprocessOptions

                                                                                                                                                                                                                                                                  interface PreprocessOptions {}

                                                                                                                                                                                                                                                                    property locals

                                                                                                                                                                                                                                                                    locals?: string[];

                                                                                                                                                                                                                                                                      property meta

                                                                                                                                                                                                                                                                      meta?: {
                                                                                                                                                                                                                                                                      moduleName?: string;
                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                        property mode

                                                                                                                                                                                                                                                                        mode?: 'codemod' | 'precompile';
                                                                                                                                                                                                                                                                        • Useful for specifying a group of options together.

                                                                                                                                                                                                                                                                          When 'codemod' we disable all whitespace control in handlebars (to preserve as much as possible) and we also avoid any escaping/unescaping of HTML entity codes.

                                                                                                                                                                                                                                                                        property parseOptions

                                                                                                                                                                                                                                                                        parseOptions?: HandlebarsParseOptions;

                                                                                                                                                                                                                                                                          property plugins

                                                                                                                                                                                                                                                                          plugins?: {
                                                                                                                                                                                                                                                                          ast?: ASTPluginBuilder[];
                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                            property strictMode

                                                                                                                                                                                                                                                                            strictMode?: boolean;

                                                                                                                                                                                                                                                                              method customizeComponentName

                                                                                                                                                                                                                                                                              customizeComponentName: (input: string) => string;

                                                                                                                                                                                                                                                                                interface Syntax

                                                                                                                                                                                                                                                                                interface Syntax {}

                                                                                                                                                                                                                                                                                  property builders

                                                                                                                                                                                                                                                                                  builders: typeof publicBuilder;

                                                                                                                                                                                                                                                                                    property parse

                                                                                                                                                                                                                                                                                    parse: typeof preprocess;

                                                                                                                                                                                                                                                                                      property print

                                                                                                                                                                                                                                                                                      print: typeof print;

                                                                                                                                                                                                                                                                                        property traverse

                                                                                                                                                                                                                                                                                        traverse: typeof traverse;

                                                                                                                                                                                                                                                                                          property Walker

                                                                                                                                                                                                                                                                                          Walker: typeof Walker;

                                                                                                                                                                                                                                                                                            interface TemplateIdFn

                                                                                                                                                                                                                                                                                            interface TemplateIdFn {}

                                                                                                                                                                                                                                                                                              call signature

                                                                                                                                                                                                                                                                                              (src: string): Option<string>;

                                                                                                                                                                                                                                                                                                Type Aliases

                                                                                                                                                                                                                                                                                                type HasSourceSpan

                                                                                                                                                                                                                                                                                                type HasSourceSpan =
                                                                                                                                                                                                                                                                                                | {
                                                                                                                                                                                                                                                                                                loc: SourceSpan;
                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                | SourceSpan
                                                                                                                                                                                                                                                                                                | [HasSourceSpan, ...HasSourceSpan[]];

                                                                                                                                                                                                                                                                                                  type KeywordType

                                                                                                                                                                                                                                                                                                  type KeywordType = 'Call' | 'Modifier' | 'Append' | 'Block';

                                                                                                                                                                                                                                                                                                    type MaybeHasSourceSpan

                                                                                                                                                                                                                                                                                                    type MaybeHasSourceSpan =
                                                                                                                                                                                                                                                                                                    | {
                                                                                                                                                                                                                                                                                                    loc: SourceSpan;
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                    | SourceSpan
                                                                                                                                                                                                                                                                                                    | MaybeHasSourceSpan[];

                                                                                                                                                                                                                                                                                                      type NodeVisitor

                                                                                                                                                                                                                                                                                                      type NodeVisitor = {
                                                                                                                                                                                                                                                                                                      [P in keyof ASTv1.Nodes]?: NodeTraversal<ASTv1.Nodes[P]>;
                                                                                                                                                                                                                                                                                                      } & {
                                                                                                                                                                                                                                                                                                      All?: NodeTraversal<ASTv1.Node>;
                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                        Namespaces

                                                                                                                                                                                                                                                                                                        namespace AST

                                                                                                                                                                                                                                                                                                        module 'dist/types/lib/v1/api.d.ts' {}

                                                                                                                                                                                                                                                                                                          interface AtHead

                                                                                                                                                                                                                                                                                                          interface AtHead {}

                                                                                                                                                                                                                                                                                                            property loc

                                                                                                                                                                                                                                                                                                            loc: SourceLocation;

                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                type: 'AtHead';

                                                                                                                                                                                                                                                                                                                  interface AttrNode

                                                                                                                                                                                                                                                                                                                  interface AttrNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                      type: 'AttrNode';

                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                        value: TextNode | MustacheStatement | ConcatStatement;

                                                                                                                                                                                                                                                                                                                          interface BaseNode

                                                                                                                                                                                                                                                                                                                          interface BaseNode {}

                                                                                                                                                                                                                                                                                                                            property loc

                                                                                                                                                                                                                                                                                                                            loc: SourceSpan;

                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                              type: NodeType;

                                                                                                                                                                                                                                                                                                                                interface Block

                                                                                                                                                                                                                                                                                                                                interface Block extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                  type: 'Block';

                                                                                                                                                                                                                                                                                                                                    interface BlockStatement

                                                                                                                                                                                                                                                                                                                                    interface BlockStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                      property chained

                                                                                                                                                                                                                                                                                                                                      chained?: boolean;

                                                                                                                                                                                                                                                                                                                                        property closeStrip

                                                                                                                                                                                                                                                                                                                                        closeStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                          property hash

                                                                                                                                                                                                                                                                                                                                          hash: Hash;

                                                                                                                                                                                                                                                                                                                                            property inverse

                                                                                                                                                                                                                                                                                                                                            inverse?: Option<Block>;

                                                                                                                                                                                                                                                                                                                                              property inverseStrip

                                                                                                                                                                                                                                                                                                                                              inverseStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                property openStrip

                                                                                                                                                                                                                                                                                                                                                openStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                  property params

                                                                                                                                                                                                                                                                                                                                                  params: Expression[];

                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                    path: Expression;

                                                                                                                                                                                                                                                                                                                                                      property program

                                                                                                                                                                                                                                                                                                                                                      program: Block;

                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                        type: 'BlockStatement';

                                                                                                                                                                                                                                                                                                                                                          interface BlockSymbols

                                                                                                                                                                                                                                                                                                                                                          interface BlockSymbols extends Symbols {}

                                                                                                                                                                                                                                                                                                                                                            property slots

                                                                                                                                                                                                                                                                                                                                                            slots: number[];

                                                                                                                                                                                                                                                                                                                                                              interface BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                              interface BooleanLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                property original

                                                                                                                                                                                                                                                                                                                                                                original: boolean;

                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                  type: 'BooleanLiteral';

                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                    value: boolean;

                                                                                                                                                                                                                                                                                                                                                                      interface Call

                                                                                                                                                                                                                                                                                                                                                                      interface Call extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                        property hash

                                                                                                                                                                                                                                                                                                                                                                        hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                          name?: Expression;

                                                                                                                                                                                                                                                                                                                                                                            property params

                                                                                                                                                                                                                                                                                                                                                                            params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                              path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                interface CallParts

                                                                                                                                                                                                                                                                                                                                                                                interface CallParts {}

                                                                                                                                                                                                                                                                                                                                                                                  property hash

                                                                                                                                                                                                                                                                                                                                                                                  hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                                                                                                                                    params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                      path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                        interface CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                        interface CommentStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                          type: 'CommentStatement';

                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                            value: string;

                                                                                                                                                                                                                                                                                                                                                                                              interface CommonProgram

                                                                                                                                                                                                                                                                                                                                                                                              interface CommonProgram extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                blockParams: string[];

                                                                                                                                                                                                                                                                                                                                                                                                  property body

                                                                                                                                                                                                                                                                                                                                                                                                  body: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                    property chained

                                                                                                                                                                                                                                                                                                                                                                                                    chained?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                      interface ConcatStatement

                                                                                                                                                                                                                                                                                                                                                                                                      interface ConcatStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                        property parts

                                                                                                                                                                                                                                                                                                                                                                                                        parts: PresentArray<TextNode | MustacheStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                          type: 'ConcatStatement';

                                                                                                                                                                                                                                                                                                                                                                                                            interface ElementModifierStatement

                                                                                                                                                                                                                                                                                                                                                                                                            interface ElementModifierStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                              property hash

                                                                                                                                                                                                                                                                                                                                                                                                              hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                property params

                                                                                                                                                                                                                                                                                                                                                                                                                params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                  path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'ElementModifierStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ElementName

                                                                                                                                                                                                                                                                                                                                                                                                                      interface ElementName {}

                                                                                                                                                                                                                                                                                                                                                                                                                        property loc

                                                                                                                                                                                                                                                                                                                                                                                                                        loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'ElementName';

                                                                                                                                                                                                                                                                                                                                                                                                                              interface ElementNode

                                                                                                                                                                                                                                                                                                                                                                                                                              interface ElementNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                property attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                attributes: AttrNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                  property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                  blockParams: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                    property children

                                                                                                                                                                                                                                                                                                                                                                                                                                    children: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                      property comments

                                                                                                                                                                                                                                                                                                                                                                                                                                      comments: MustacheCommentStatement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                        property modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                        modifiers: ElementModifierStatement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                          property selfClosing

                                                                                                                                                                                                                                                                                                                                                                                                                                          selfClosing: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                            tag: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'ElementNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FreeVarHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                interface FreeVarHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                  loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'FreeVarHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Hash extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property pairs

                                                                                                                                                                                                                                                                                                                                                                                                                                                          pairs: HashPair[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'Hash';

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HashPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HashPair extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'HashPair';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LocalVarHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface LocalVarHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'LocalVarHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MinimalPathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MinimalPathExpression extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property head

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                head: PathHead;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  tail: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'PathExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MustacheCommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MustacheCommentStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'MustacheCommentStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface MustacheStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property escaped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              escaped: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property trusting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      trusting: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'MustacheStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NamedBlockName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NamedBlockName {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'NamedBlockName';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NullLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    original: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'NullLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NumberLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            original: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'NumberLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PartialStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property indent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      indent: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: PathExpression | SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'PartialStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PathExpression extends MinimalPathExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    use `head.type' instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property head

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  head: PathHead;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      parts: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        use head and tail instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      tail: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property this

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        this: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          use head.type instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'PathExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface Position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface SourcePosition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • >= 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • >= 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Program extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              symbols?: Symbols;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'Program';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ProgramSymbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ProgramSymbols extends Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property freeVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    freeVariables: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end: SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          start: SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SourcePosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SourcePosition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • >= 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • >= 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StringLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'StringLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StripFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StripFlags {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        close: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          open: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SubExpression extends Call {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'SubExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        symbols: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method allocate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allocate: (identifier: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method allocateBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            allocateBlock: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method allocateFree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allocateFree: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method allocateNamed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                allocateNamed: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  child: (locals: string[]) => BlockSymbols;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    get: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getEvalInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getEvalInfo: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getLocalsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        getLocalsMap: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          has: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Template extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'Template';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TextNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface TextNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property chars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  chars: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'TextNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ThisHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ThisHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'ThisHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface UndefinedLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              original: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'UndefinedLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VarHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface VarHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'VarHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AttrValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type AttrValue = TextNode | MustacheStatement | ConcatStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CallNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type CallNode =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MustacheStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | BlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ElementModifierStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EntityEncodingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type EntityEncodingState = 'transformed' | 'raw';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Expression = Nodes[ExpressionName];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExpressionName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type ExpressionName = 'SubExpression' | 'PathExpression' | LiteralName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Expressions = Pick<Nodes, ExpressionName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Literal = Nodes[LiteralName];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LiteralName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type LiteralName =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'StringLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'BooleanLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'NumberLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'UndefinedLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'NullLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Node = Nodes[NodeType];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Nodes = SharedNodes & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Program: Program;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Template: Template;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Block: Block;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BlockStatement: BlockStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ElementNode: ElementNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SubExpression: SubExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PathExpression: PathExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hash: Hash;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              HashPair: HashPair;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type NodeType = keyof Nodes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PathHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type PathHead = ThisHead | AtHead | VarHead;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PossiblyDeprecatedBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type PossiblyDeprecatedBlock = Block | Template;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SharedNodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SharedNodes = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CommentStatement: CommentStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MustacheCommentStatement: MustacheCommentStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      TextNode: TextNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StringLiteral: StringLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BooleanLiteral: BooleanLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NumberLiteral: NumberLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NullLiteral: NullLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      UndefinedLiteral: UndefinedLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MustacheStatement: MustacheStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ElementModifierStatement: ElementModifierStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PartialStatement: PartialStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AttrNode: AttrNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ConcatStatement: ConcatStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Statement = Nodes[StatementName];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type StatementName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type StatementName =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'MustacheStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'CommentStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'BlockStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'PartialStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'MustacheCommentStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'TextNode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 'ElementNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Statements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Statements = Pick<Nodes, StatementName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TopLevelStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TopLevelStatement = Statement | Nodes['Block'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                namespace ASTv1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                module 'dist/types/lib/v1/api.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface AtHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface AtHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'AtHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface AttrNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface AttrNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'AttrNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: TextNode | MustacheStatement | ConcatStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BaseNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loc: SourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: NodeType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Block extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Block';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface BlockStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property chained

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              chained?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property closeStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                closeStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property inverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    inverse?: Option<Block>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property inverseStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      inverseStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property openStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        openStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              program: Block;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'BlockStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BlockSymbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface BlockSymbols extends Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property slots

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    slots: number[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface BooleanLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        original: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'BooleanLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Call

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Call extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name?: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CallParts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface CallParts {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommentStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'CommentStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CommonProgram

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface CommonProgram extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        blockParams: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property chained

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            chained?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConcatStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ConcatStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                parts: PresentArray<TextNode | MustacheStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'ConcatStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ElementModifierStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface ElementModifierStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'ElementModifierStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ElementName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ElementName {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'ElementName';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ElementNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface ElementNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property attributes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        attributes: AttrNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          blockParams: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            children: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property comments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              comments: MustacheCommentStatement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property modifiers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                modifiers: ElementModifierStatement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property selfClosing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  selfClosing: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property tag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    tag: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'ElementNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FreeVarHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface FreeVarHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'FreeVarHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Hash extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property pairs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  pairs: HashPair[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'Hash';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HashPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface HashPair extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'HashPair';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LocalVarHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LocalVarHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'LocalVarHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MinimalPathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface MinimalPathExpression extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property head

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        head: PathHead;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tail: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'PathExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MustacheCommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MustacheCommentStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'MustacheCommentStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface MustacheStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property escaped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      escaped: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property trusting

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              trusting: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'MustacheStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NamedBlockName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NamedBlockName {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'NamedBlockName';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface NullLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            original: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'NullLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NumberLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    original: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'NumberLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PartialStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property indent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              indent: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: PathExpression | SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'PartialStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PathExpression extends MinimalPathExpression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            use `head.type' instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property head

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          head: PathHead;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parts: string[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                use head and tail instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property tail

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              tail: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property this

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                this: boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  use head.type instead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'PathExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface Position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface SourcePosition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • >= 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • >= 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Program extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      symbols?: Symbols;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'Program';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ProgramSymbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface ProgramSymbols extends Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property freeVariables

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            freeVariables: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end: SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SourcePosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SourcePosition {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      column: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • >= 0

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      line: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • >= 1

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StringLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'StringLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StripFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StripFlags {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                close: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  open: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SubExpression extends Call {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'SubExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                symbols: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method allocate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  allocate: (identifier: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method allocateBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    allocateBlock: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method allocateFree

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allocateFree: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method allocateNamed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allocateNamed: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          child: (locals: string[]) => BlockSymbols;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            get: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getEvalInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getEvalInfo: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getLocalsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getLocalsMap: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  has: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Template extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'Template';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TextNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TextNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property chars

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          chars: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'TextNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ThisHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ThisHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'ThisHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface UndefinedLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      original: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'UndefinedLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          value: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VarHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface VarHead {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'VarHead';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AttrValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type AttrValue = TextNode | MustacheStatement | ConcatStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CallNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type CallNode =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | MustacheStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | BlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | ElementModifierStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EntityEncodingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type EntityEncodingState = 'transformed' | 'raw';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Expression = Nodes[ExpressionName];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ExpressionName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ExpressionName = 'SubExpression' | 'PathExpression' | LiteralName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Expressions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Expressions = Pick<Nodes, ExpressionName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Literal = Nodes[LiteralName];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LiteralName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type LiteralName =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'StringLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'BooleanLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'NumberLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'UndefinedLiteral'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'NullLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Node = Nodes[NodeType];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Nodes = SharedNodes & {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Program: Program;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Template: Template;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Block: Block;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      BlockStatement: BlockStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ElementNode: ElementNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SubExpression: SubExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PathExpression: PathExpression;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Hash: Hash;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      HashPair: HashPair;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeType = keyof Nodes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PathHead

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type PathHead = ThisHead | AtHead | VarHead;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PossiblyDeprecatedBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PossiblyDeprecatedBlock = Block | Template;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SharedNodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SharedNodes = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              CommentStatement: CommentStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MustacheCommentStatement: MustacheCommentStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TextNode: TextNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              StringLiteral: StringLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BooleanLiteral: BooleanLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NumberLiteral: NumberLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              NullLiteral: NullLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UndefinedLiteral: UndefinedLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MustacheStatement: MustacheStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ElementModifierStatement: ElementModifierStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PartialStatement: PartialStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              AttrNode: AttrNode;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ConcatStatement: ConcatStatement;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Statement = Nodes[StatementName];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StatementName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type StatementName =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'MustacheStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'CommentStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'BlockStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'PartialStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'MustacheCommentStatement'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'TextNode'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 'ElementNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Statements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Statements = Pick<Nodes, StatementName>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TopLevelStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TopLevelStatement = Statement | Nodes['Block'];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace ASTv2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        module 'dist/types/lib/v2-a/api.d.ts' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable ARGUMENT_RESOLUTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const ARGUMENT_RESOLUTION: LooseModeResolution;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable STRICT_RESOLUTION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const STRICT_RESOLUTION: StrictResolution;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isLiteral: <K extends keyof LiteralTypes = keyof LiteralTypes>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: ExpressionNode,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              kind?: K
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => node is StringLiteral;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Returns true if an input is a literal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function loadResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loadResolution: (resolution: SerializedResolution) => FreeVarResolution;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (): {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fields<Fields extends object>(): NodeConstructor<Fields & BaseNodeFields>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <T extends string>(name: T): {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fields<Fields extends object>(): TypedNodeConstructor<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Fields & BaseNodeFields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • This is a convenience function for creating ASTv2 nodes, with an optional name and the node's options.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  export class HtmlText extends node('HtmlText').fields<{ chars: string }>() {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This creates a new ASTv2 node with the name 'HtmlText' and one field chars: string (in addition to a loc: SourceOffsets field, which all nodes have).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  export class Args extends node().fields<{
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  positional: PositionalArguments;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  named: NamedArguments
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }>() {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  This creates a new un-named ASTv2 node with two fields (positional: Positional and `named: Named, in addition to the generic loc: SourceOffsets` field).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Once you create a node using node, it is instantiated with all of its fields (including loc):

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  new HtmlText({ loc: offsets, chars: someString });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class AppendContent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class AppendContent extends AppendContent_base {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly args: Args;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property callee

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly callee: ExpressionNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ArgReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class ArgReference extends ArgReference_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Corresponds to @<ident> at the beginning of an expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class Args extends Args_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Corresponds to syntaxes with positional and named arguments:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        - SubExpression - Invoking Append - Invoking attributes - InvokeBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        If Args is empty, the SourceOffsets for this node should be the collapsed position immediately after the parent call node's callee.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static empty: (loc: SourceSpan) => Args;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        get: (name: string) => ExpressionNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method named

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            static named: (named: NamedArguments) => Args;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method nth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nth: (offset: number) => ExpressionNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Block extends Block_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Represents a block. In principle this could be merged with NamedBlock, because all cases involving blocks have at least a notional name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class CallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class CallExpression extends CallExpression_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Corresponds to a parenthesized call expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (x)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (x.y)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (x y)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  (x.y z)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ComponentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ComponentArg extends ComponentArg_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Corresponds to an argument passed by a component (@x=<value>)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toNamedArgument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toNamedArgument: () => NamedArgument;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Convert the component argument into a named argument node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class DeprecatedCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class DeprecatedCallExpression extends DeprecatedCallExpression_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Corresponds to a possible deprecated helper call. Must be:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  1. A free variable (not this.foo, not @foo, not local). 2. Argument-less. 3. In a component invocation's named argument position. 4. Not parenthesized (not @bar={{(helper)}}). 5. Not interpolated (not @bar="{{helper}}").

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <Foo @bar={{helper}} />

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ElementModifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class ElementModifier extends ElementModifier_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • An ElementModifier is just a normal call node in modifier position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class FreeVarReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class FreeVarReference extends FreeVarReference_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Corresponds to <ident> at the beginning of an expression, when <ident> is *not* in the current block's scope.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  The resolution: FreeVarResolution field describes how to resolve the free variable.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Note: In strict mode, it must always be a variable that is in a concrete JavaScript scope that the template will be installed into.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class GlimmerComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class GlimmerComment extends GlimmerComment_base {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class HtmlAttr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class HtmlAttr extends HtmlAttr_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • HtmlAttr nodes are valid HTML attributes, with or without a value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Exceptions:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    - ...attributes is SplatAttr - @x=<value> is ComponentArg

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class HtmlComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class HtmlComment extends HtmlComment_base {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HtmlText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class HtmlText extends HtmlText_base {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class InterpolateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class InterpolateExpression extends InterpolateExpression_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Corresponds to an interpolation in attribute value position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <a href="{{url}}.html"

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class InvokeBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class InvokeBlock extends InvokeBlock_base {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class InvokeComponent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class InvokeComponent extends InvokeComponent_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Corresponds to a component invocation. When the content of a component invocation contains no named blocks, blocks contains a single named block named "default". When a component invocation is self-closing, blocks is empty.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly args: Args;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class LiteralExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class LiteralExpression extends LiteralExpression_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Corresponds to a Handlebars literal.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • {LiteralValue}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toSlice

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toSlice: (this: StringLiteral) => SourceSlice;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LocalVarReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LocalVarReference extends LocalVarReference_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Corresponds to <ident> at the beginning of an expression, when <ident> is in the current block's scope.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LooseModeResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            class LooseModeResolution {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • A LooseModeResolution includes:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              - 0 or more namespaces to resolve the variable in - optional fallback behavior

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              In practice, there are a limited number of possible combinations of these degrees of freedom, and they are captured by the Ambiguity union below.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(ambiguity: Ambiguity, isAngleBracket?: boolean);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ambiguity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly ambiguity: Ambiguity;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isAngleBracket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly isAngleBracket: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method append

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static append: ({ invoke }: { invoke: boolean }) => LooseModeResolution;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Append resolution is used when the variable should be resolved in both the component and helper namespaces. Fallback resolution is optional.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {{x}}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^ x should be resolved in the component and helper namespaces with fallback resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {{x y}}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^ x should be resolved in the component and helper namespaces without fallback resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {ComponentOrHelperAmbiguity}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method attr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static attr: () => LooseModeResolution;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Attribute resolution is used when the variable should be resolved as a helper with fallback resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <a href={{x}} />
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <a href="{{x}}.html" />

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ^ resolved in the helper namespace with fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {HelperAmbiguity}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method fallback

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static fallback: () => LooseModeResolution;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Fallback resolution is used when no namespaced resolutions are possible, but fallback resolution is still allowed.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {{x.y}}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {FallbackAmbiguity}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method namespaced

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  static namespaced: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace: FreeVarNamespace,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isAngleBracket?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => LooseModeResolution;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Namespaced resolution is used in an unambiguous syntax position:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    1. (sexp) (namespace: Helper) 2. {{#block}} (namespace: Component) 3. <a {{modifier}}> (namespace: Modifier) 4. <Component /> (namespace: Component)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • {NamespacedAmbiguity}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method resolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  resolution: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serialize: () => SerializedResolution;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method trustingAppend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      static trustingAppend: ({ invoke }: { invoke: boolean }) => LooseModeResolution;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Trusting append resolution is used when the variable should be resolved in both the component and helper namespaces. Fallback resolution is optional.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {{{x}}}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^ x should be resolved in the component and helper namespaces with fallback resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {{{x y}}}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ^ x should be resolved in the component and helper namespaces without fallback resolution.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        See Also

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • {HelperAmbiguity}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NamedArgument

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NamedArgument {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Corresponds to a single named argument.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x=<expr>

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(options: { name: SourceSlice; value: ExpressionNode });

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly loc: SourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly name: SourceSlice<string>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly value: ExpressionNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class NamedArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class NamedArguments extends NamedArguments_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Corresponds to named arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If PositionalArguments and NamedArguments are empty, the SourceOffsets for this node should be the same as the Args node that contains this node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If PositionalArguments is not empty but NamedArguments is empty, the SourceOffsets for this node should be the collapsed position immediately after the last positional argument.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                static empty: (loc: SourceSpan) => NamedArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  get: (name: string) => ExpressionNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NamedBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class NamedBlock extends NamedBlock_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Corresponds to a single named block. This is used for anonymous named blocks (default and else).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly args: Args;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class NamedBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class NamedBlocks extends NamedBlocks_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Corresponds to a collection of named blocks.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        get: { (name: 'default'): NamedBlock; (name: string): NamedBlock };
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Get the NamedBlock for a given name.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PathExpression extends PathExpression_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Corresponds to a path in expression position.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          this
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          this.x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          @x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          @x.y
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x.y

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PositionalArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class PositionalArguments extends PositionalArguments_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Corresponds to positional arguments.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          If PositionalArguments is empty, the SourceOffsets for this node should be the collapsed position immediately after the parent call node's callee.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property size

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly size: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          static empty: (loc: SourceSpan) => PositionalArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isEmpty: () => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method nth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nth: (offset: number) => ExpressionNode | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SimpleElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class SimpleElement extends SimpleElement_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Corresponds to a simple HTML element. The AST allows component arguments and modifiers to support future extensions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property args

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly args: Args;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SplatAttr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class SplatAttr extends SplatAttr_base {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StrictResolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class StrictResolution {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Strict resolution is used:

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      1. in a strict mode template 2. in an unambiguous invocation with dot paths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property isAngleBracket

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly isAngleBracket: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method resolution

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      resolution: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        serialize: () => SerializedResolution;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class Template extends Template_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Corresponds to an entire template.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ThisReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class ThisReference extends ThisReference_base {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Corresponds to this at the head of an expression.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface AttrNodeOptions