@glimmer/syntax

  • Version 0.92.0
  • Published
  • 1.52 MB
  • 5 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 BROKEN

const BROKEN: string;
  • Used to indicate that an attempt to convert a SourcePosition to a character offset failed. It is separate from null so that null can be used to indicate that the computation wasn't yet attempted (and therefore to cache the failure)

variable builders

const builders: {
mustache: typeof buildMustache;
block: typeof buildBlock;
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;
string: (value: string) => ASTv1.StringLiteral;
boolean: (value: boolean) => ASTv1.BooleanLiteral;
number: (value: number) => ASTv1.NumberLiteral;
undefined(): ASTv1.UndefinedLiteral;
null(): ASTv1.NullLiteral;
};

    variable IsInvisible

    const IsInvisible: string;

      variable KEYWORDS_TYPES

      const KEYWORDS_TYPES: {
      action: ('Call' | 'Modifier')[];
      component: ('Block' | 'Call' | 'Append')[];
      debugger: 'Append'[];
      'each-in': 'Block'[];
      each: 'Block'[];
      'has-block-params': ('Call' | 'Append')[];
      'has-block': ('Call' | 'Append')[];
      helper: ('Call' | 'Append')[];
      if: ('Block' | 'Call' | 'Append')[];
      'in-element': 'Block'[];
      let: 'Block'[];
      log: ('Call' | 'Append')[];
      modifier: ('Call' | 'Modifier')[];
      mount: 'Append'[];
      mut: ('Call' | 'Append')[];
      outlet: 'Append'[];
      readonly: ('Call' | 'Append')[];
      unbound: ('Call' | 'Append')[];
      unless: ('Block' | 'Call' | 'Append')[];
      yield: 'Append'[];
      };
      • This includes the full list of keywords currently in use in the template language, and where their valid usages are.

      variable MatchAny

      const MatchAny: string;
      • This file implements the DSL used by span and offset in places where they need to exhaustively consider all combinations of states (Handlebars offsets, character offsets and invisible/broken offsets).

        It's probably overkill, but it makes the code that uses it clear. It could be refactored or removed.

      variable print

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

        variable publicBuilder

        const publicBuilder: {
        mustache: (
        path: BuilderHead | ASTv1.Literal,
        params?: ASTv1.Expression[],
        hash?: ASTv1.Hash,
        trusting?: boolean,
        loc?: SourceLocation,
        strip?: ASTv1.StripFlags
        ) => ASTv1.MustacheStatement;
        block: (
        path: BuilderHead,
        params: Nullable<ASTv1.Expression[]>,
        hash: Nullable<ASTv1.Hash>,
        _defaultBlock: PossiblyDeprecatedBlock,
        _elseBlock?: Nullable<PossiblyDeprecatedBlock>,
        loc?: SourceLocation,
        openStrip?: ASTv1.StripFlags,
        inverseStrip?: ASTv1.StripFlags,
        closeStrip?: ASTv1.StripFlags
        ) => ASTv1.BlockStatement;
        comment: (value: string, loc?: SourceLocation) => ASTv1.CommentStatement;
        mustacheComment: (
        value: string,
        loc?: SourceLocation
        ) => ASTv1.MustacheCommentStatement;
        element: (
        tag: TagDescriptor,
        options?: BuildElementOptions
        ) => ASTv1.ElementNode;
        elementModifier: (
        path: BuilderHead,
        params?: ASTv1.Expression[],
        hash?: ASTv1.Hash,
        loc?: Nullable<SourceLocation>
        ) => ASTv1.ElementModifierStatement;
        attr: (
        name: string,
        value: ASTv1.AttrValue,
        loc?: SourceLocation
        ) => ASTv1.AttrNode;
        text: (chars?: string, loc?: SourceLocation) => ASTv1.TextNode;
        sexpr: (
        path: BuilderHead,
        params?: ASTv1.Expression[],
        hash?: ASTv1.Hash,
        loc?: SourceLocation
        ) => ASTv1.SubExpression;
        concat: (
        parts: (ASTv1.MustacheStatement | ASTv1.TextNode)[],
        loc?: SourceLocation
        ) => ASTv1.ConcatStatement;
        hash: (pairs?: ASTv1.HashPair[], loc?: SourceLocation) => ASTv1.Hash;
        pair: (
        key: string,
        value: ASTv1.Expression,
        loc?: SourceLocation
        ) => ASTv1.HashPair;
        literal: <T extends ASTv1.Literal>(
        type: T['type'],
        value: T['value'],
        loc?: SourceLocation
        ) => T;
        program: (
        body?: ASTv1.Statement[],
        blockParams?: string[],
        loc?: SourceLocation
        ) => ASTv1.Template | ASTv1.Block;
        blockItself: (
        body?: ASTv1.Statement[],
        params?: (string | ASTv1.VarHead)[],
        chained?: boolean,
        loc?: SourceLocation
        ) => ASTv1.Block;
        template: (
        body?: ASTv1.Statement[],
        blockParams?: string[],
        loc?: SourceLocation
        ) => ASTv1.Template;
        loc: {
        (loc: Nullable<SourceLocation>): SourceSpan;
        (
        startLine: number,
        startColumn: number,
        endLine?: number,
        endColumn?: number,
        source?: string
        ): SourceSpan;
        };
        pos: (line: number, column: number) => SourcePosition;
        path: {
        (
        path: string | ASTv1.PathExpression | { head: string; tail: string[] },
        loc?: SourceLocation
        ): ASTv1.PathExpression;
        (path: BuilderHead, loc?: SourceLocation): ASTv1.CallableExpression;
        (path: BuilderHead | ASTv1.Literal, loc?: SourceLocation): ASTv1.Expression;
        (path: ASTv1.Expression, loc?: SourceLocation): ASTv1.Expression;
        };
        fullPath: (
        head: ASTv1.PathHead,
        tail?: string[],
        loc?: SourceLocation
        ) => ASTv1.PathExpression;
        head: (original: string, loc?: SourceLocation) => ASTv1.PathHead;
        at: (name: string, loc?: SourceLocation) => ASTv1.AtHead;
        var: (name: string, loc?: SourceLocation) => ASTv1.VarHead;
        this: (loc?: SourceLocation) => ASTv1.ThisHead;
        string: (value: string) => ASTv1.StringLiteral;
        boolean: (value: boolean) => ASTv1.BooleanLiteral;
        number: (value: number) => ASTv1.NumberLiteral;
        undefined(): ASTv1.UndefinedLiteral;
        null(): ASTv1.NullLiteral;
        };

          variable span

          const span: MatchFn<SourceSpan>;

            variable TraversalError

            const TraversalError: TraversalErrorConstructor;

              variable visitorKeys

              const visitorKeys: {
              readonly Template: readonly ['body'];
              readonly Block: readonly ['body'];
              readonly MustacheStatement: readonly ['path', 'params', 'hash'];
              readonly BlockStatement: readonly [
              'path',
              'params',
              'hash',
              'program',
              'inverse'
              ];
              readonly ElementModifierStatement: readonly ['path', 'params', 'hash'];
              readonly CommentStatement: readonly [];
              readonly MustacheCommentStatement: readonly [];
              readonly ElementNode: readonly [
              'attributes',
              'modifiers',
              'children',
              'comments'
              ];
              readonly AttrNode: readonly ['value'];
              readonly TextNode: readonly [];
              readonly ConcatStatement: readonly ['parts'];
              readonly SubExpression: readonly ['path', 'params', 'hash'];
              readonly PathExpression: readonly [];
              readonly StringLiteral: readonly [];
              readonly BooleanLiteral: readonly [];
              readonly NumberLiteral: readonly [];
              readonly NullLiteral: readonly [];
              readonly UndefinedLiteral: readonly [];
              readonly Hash: readonly ['pairs'];
              readonly HashPair: readonly ['value'];
              };

                Functions

                function buildAtName

                buildAtName: (name: string, loc?: SourceLocation) => ASTv1.AtHead;

                  function buildAttr

                  buildAttr: (
                  name: string,
                  value: ASTv1.AttrValue,
                  loc?: SourceLocation
                  ) => ASTv1.AttrNode;

                    function buildBlock

                    buildBlock: (
                    path: BuilderHead,
                    params: Nullable<ASTv1.Expression[]>,
                    hash: Nullable<ASTv1.Hash>,
                    _defaultBlock: PossiblyDeprecatedBlock,
                    _elseBlock?: Nullable<PossiblyDeprecatedBlock>,
                    loc?: SourceLocation,
                    openStrip?: ASTv1.StripFlags,
                    inverseStrip?: ASTv1.StripFlags,
                    closeStrip?: ASTv1.StripFlags
                    ) => ASTv1.BlockStatement;

                      function buildBlockItself

                      buildBlockItself: (
                      body?: ASTv1.Statement[],
                      params?: Array<ASTv1.VarHead | string>,
                      chained?: boolean,
                      loc?: SourceLocation
                      ) => ASTv1.Block;

                        function buildCleanPath

                        buildCleanPath: (
                        head: ASTv1.PathHead,
                        tail?: string[],
                        loc?: SourceLocation
                        ) => ASTv1.PathExpression;

                          function buildComment

                          buildComment: (value: string, loc?: SourceLocation) => ASTv1.CommentStatement;

                            function buildConcat

                            buildConcat: (
                            parts: (ASTv1.TextNode | ASTv1.MustacheStatement)[],
                            loc?: SourceLocation
                            ) => ASTv1.ConcatStatement;

                              function buildElement

                              buildElement: (
                              tag: TagDescriptor,
                              options?: BuildElementOptions
                              ) => ASTv1.ElementNode;

                                function buildElementModifier

                                buildElementModifier: (
                                path: BuilderHead,
                                params?: ASTv1.Expression[],
                                hash?: ASTv1.Hash,
                                loc?: Nullable<SourceLocation>
                                ) => ASTv1.ElementModifierStatement;

                                  function buildHash

                                  buildHash: (pairs?: ASTv1.HashPair[], loc?: SourceLocation) => ASTv1.Hash;

                                    function buildHeadFromString

                                    buildHeadFromString: (original: string, loc?: SourceLocation) => ASTv1.PathHead;

                                      function buildLiteral

                                      buildLiteral: <T extends ASTv1.Literal>(
                                      type: T['type'],
                                      value: T['value'],
                                      loc?: SourceLocation
                                      ) => T;

                                        function buildLoc

                                        buildLoc: {
                                        (loc: Nullable<SourceLocation>): SourceSpan;
                                        (
                                        startLine: number,
                                        startColumn: number,
                                        endLine?: number,
                                        endColumn?: number,
                                        source?: string
                                        ): SourceSpan;
                                        };

                                          function buildMustache

                                          buildMustache: (
                                          path: BuilderHead | ASTv1.Literal,
                                          params?: ASTv1.Expression[],
                                          hash?: ASTv1.Hash,
                                          trusting?: boolean,
                                          loc?: SourceLocation,
                                          strip?: ASTv1.StripFlags
                                          ) => ASTv1.MustacheStatement;

                                            function buildMustacheComment

                                            buildMustacheComment: (
                                            value: string,
                                            loc?: SourceLocation
                                            ) => ASTv1.MustacheCommentStatement;

                                              function buildPair

                                              buildPair: (
                                              key: string,
                                              value: ASTv1.Expression,
                                              loc?: SourceLocation
                                              ) => ASTv1.HashPair;

                                                function buildPath

                                                buildPath: {
                                                (
                                                path: ASTv1.PathExpression | string | { head: string; tail: string[] },
                                                loc?: SourceLocation
                                                ): ASTv1.PathExpression;
                                                (path: BuilderHead, loc?: SourceLocation): ASTv1.CallableExpression;
                                                (path: BuilderHead | ASTv1.Literal, loc?: SourceLocation): ASTv1.Expression;
                                                (path: ASTv1.Expression, loc?: SourceLocation): ASTv1.Expression;
                                                };

                                                  function buildPosition

                                                  buildPosition: (line: number, column: number) => SourcePosition;

                                                    function buildProgram

                                                    buildProgram: (
                                                    body?: ASTv1.Statement[],
                                                    blockParams?: string[],
                                                    loc?: SourceLocation
                                                    ) => ASTv1.Template | ASTv1.Block;

                                                      function buildSexpr

                                                      buildSexpr: (
                                                      path: BuilderHead,
                                                      params?: ASTv1.Expression[],
                                                      hash?: ASTv1.Hash,
                                                      loc?: SourceLocation
                                                      ) => ASTv1.SubExpression;

                                                        function buildTemplate

                                                        buildTemplate: (
                                                        body?: ASTv1.Statement[],
                                                        blockParams?: string[],
                                                        loc?: SourceLocation
                                                        ) => ASTv1.Template;

                                                          function buildText

                                                          buildText: (chars?: string, loc?: SourceLocation) => ASTv1.TextNode;

                                                            function buildThis

                                                            buildThis: (loc?: SourceLocation) => ASTv1.ThisHead;

                                                              function buildVar

                                                              buildVar: (name: string, loc?: SourceLocation) => ASTv1.VarHead;

                                                                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: src.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 parent scope. Can exclude known keywords optionally.

                                                                      function getVoidTags

                                                                      getVoidTags: () => string[];

                                                                        function hasSpan

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

                                                                          function isKeyword

                                                                          isKeyword: {
                                                                          (word: string): word is
                                                                          | 'action'
                                                                          | 'component'
                                                                          | 'debugger'
                                                                          | 'each-in'
                                                                          | 'each'
                                                                          | 'has-block-params'
                                                                          | 'has-block'
                                                                          | 'helper'
                                                                          | 'if'
                                                                          | 'in-element'
                                                                          | 'let'
                                                                          | 'log'
                                                                          | 'modifier'
                                                                          | 'mount'
                                                                          | 'mut'
                                                                          | 'outlet'
                                                                          | 'readonly'
                                                                          | 'unbound'
                                                                          | 'unless'
                                                                          | 'yield';
                                                                          (word: string, type: KeywordType): boolean;
                                                                          };

                                                                            function isVoidTag

                                                                            isVoidTag: (tag: string) => boolean;
                                                                            • Examples when true: - link - liNK

                                                                              Examples when false: - Link (component)

                                                                            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?: PrecompileOptionsWithLexicalScope
                                                                                ) => [ast: ASTv2.Template, locals: string[]];

                                                                                  function preprocess

                                                                                  preprocess: (
                                                                                  input: string | src.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 getDebugInfo

                                                                                                              getDebugInfo: () => Core.DebugInfo;

                                                                                                                method getKeyword

                                                                                                                getKeyword: (name: string) => number;

                                                                                                                  method getLocalsMap

                                                                                                                  getLocalsMap: () => Dict<number>;

                                                                                                                    method has

                                                                                                                    has: (name: string) => boolean;

                                                                                                                      method hasKeyword

                                                                                                                      hasKeyword: (name: string) => boolean;

                                                                                                                        method hasLexical

                                                                                                                        hasLexical: (name: string) => boolean;

                                                                                                                          method setHasDebugger

                                                                                                                          setHasDebugger: () => 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: Nullable<N>,
                                                                                                                                      visitor: NodeCallback<N>
                                                                                                                                      ) => void;

                                                                                                                                        class ProgramSymbolTable

                                                                                                                                        class ProgramSymbolTable extends SymbolTable {}

                                                                                                                                          constructor

                                                                                                                                          constructor(
                                                                                                                                          templateLocals: readonly string[],
                                                                                                                                          keywords: readonly string[],
                                                                                                                                          options: SymbolTableOptions
                                                                                                                                          );

                                                                                                                                            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 getDebugInfo

                                                                                                                                                            getDebugInfo: () => Core.DebugInfo;

                                                                                                                                                              method getKeyword

                                                                                                                                                              getKeyword: (name: string) => number;

                                                                                                                                                                method getLocalsMap

                                                                                                                                                                getLocalsMap: () => Dict<number>;

                                                                                                                                                                  method getUsedTemplateLocals

                                                                                                                                                                  getUsedTemplateLocals: () => string[];

                                                                                                                                                                    method has

                                                                                                                                                                    has: (name: string) => boolean;

                                                                                                                                                                      method hasKeyword

                                                                                                                                                                      hasKeyword: (name: string) => boolean;

                                                                                                                                                                        method hasLexical

                                                                                                                                                                        hasLexical: (name: string) => boolean;

                                                                                                                                                                          method setHasDebugger

                                                                                                                                                                          setHasDebugger: () => void;

                                                                                                                                                                            class SourceSlice

                                                                                                                                                                            class SourceSlice<Chars extends string = string> {}

                                                                                                                                                                              constructor

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

                                                                                                                                                                                property chars

                                                                                                                                                                                readonly chars: string;

                                                                                                                                                                                  property loc

                                                                                                                                                                                  readonly loc: src.SourceSpan;

                                                                                                                                                                                    method getString

                                                                                                                                                                                    getString: () => string;

                                                                                                                                                                                      method load

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

                                                                                                                                                                                        method serialize

                                                                                                                                                                                        serialize: () => SerializedSourceSlice<Chars>;

                                                                                                                                                                                          method synthetic

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

                                                                                                                                                                                            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: PresentArray<HasSourceSpan>): 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 getDebugInfo

                                                                                                                                                                                                                    abstract getDebugInfo: () => Core.DebugInfo;

                                                                                                                                                                                                                      method getKeyword

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

                                                                                                                                                                                                                        method getLocalsMap

                                                                                                                                                                                                                        abstract getLocalsMap: () => Dict<number>;

                                                                                                                                                                                                                          method has

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

                                                                                                                                                                                                                            method hasKeyword

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

                                                                                                                                                                                                                              method hasLexical

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

                                                                                                                                                                                                                                method setHasDebugger

                                                                                                                                                                                                                                abstract setHasDebugger: () => void;

                                                                                                                                                                                                                                  method top

                                                                                                                                                                                                                                  static top: (
                                                                                                                                                                                                                                  locals: readonly string[],
                                                                                                                                                                                                                                  keywords: readonly string[],
                                                                                                                                                                                                                                  options: SymbolTableOptions
                                                                                                                                                                                                                                  ) => 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: Nullable<N>,
                                                                                                                                                                                                                                              visitor: 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;

                                                                                                                                                                                                                                                            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: src.SourceSpan | null;

                                                                                                                                                                                                                                                                                  interface PrecompileOptions

                                                                                                                                                                                                                                                                                  interface PrecompileOptions extends PreprocessOptions {}

                                                                                                                                                                                                                                                                                    property customizeComponentName

                                                                                                                                                                                                                                                                                    customizeComponentName?: ((input: string) => string) | undefined;

                                                                                                                                                                                                                                                                                      property id

                                                                                                                                                                                                                                                                                      id?: TemplateIdFn;

                                                                                                                                                                                                                                                                                        property keywords

                                                                                                                                                                                                                                                                                        keywords?: readonly string[];
                                                                                                                                                                                                                                                                                        • Additional non-native keywords.

                                                                                                                                                                                                                                                                                          Local variables (block params or lexical scope) always takes precedence, but otherwise, suitable free variable candidates (e.g. those are not part of a path) are matched against this list and turned into keywords.

                                                                                                                                                                                                                                                                                          In strict mode compilation, keywords suppresses the undefined reference error and will be resolved by the runtime environment.

                                                                                                                                                                                                                                                                                          In loose mode, keywords are currently ignored and since all free variables are already resolved by the runtime environment.

                                                                                                                                                                                                                                                                                        interface PrecompileOptionsWithLexicalScope

                                                                                                                                                                                                                                                                                        interface PrecompileOptionsWithLexicalScope extends PrecompileOptions {}

                                                                                                                                                                                                                                                                                          property lexicalScope

                                                                                                                                                                                                                                                                                          lexicalScope: (variable: string) => boolean;

                                                                                                                                                                                                                                                                                            interface PreprocessOptions

                                                                                                                                                                                                                                                                                            interface PreprocessOptions {}

                                                                                                                                                                                                                                                                                              property customizeComponentName

                                                                                                                                                                                                                                                                                              customizeComponentName?: ((input: string) => string) | undefined;

                                                                                                                                                                                                                                                                                                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;

                                                                                                                                                                                                                                                                                                          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): Nullable<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>;
                                                                                                                                                                                                                                                                                                                                /**
                                                                                                                                                                                                                                                                                                                                * @deprecated use Template or Block instead
                                                                                                                                                                                                                                                                                                                                */
                                                                                                                                                                                                                                                                                                                                Program?: NodeTraversal<ASTv1.Template | ASTv1.Block>;
                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                  Namespaces

                                                                                                                                                                                                                                                                                                                                  namespace AST

                                                                                                                                                                                                                                                                                                                                  namespace AST {}

                                                                                                                                                                                                                                                                                                                                    variable BROKEN

                                                                                                                                                                                                                                                                                                                                    const BROKEN: string;
                                                                                                                                                                                                                                                                                                                                    • Used to indicate that an attempt to convert a SourcePosition to a character offset failed. It is separate from null so that null can be used to indicate that the computation wasn't yet attempted (and therefore to cache the failure)

                                                                                                                                                                                                                                                                                                                                    variable BROKEN_LOCATION

                                                                                                                                                                                                                                                                                                                                    const BROKEN_LOCATION: Readonly<{
                                                                                                                                                                                                                                                                                                                                    readonly source: '(broken)';
                                                                                                                                                                                                                                                                                                                                    readonly start: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                    readonly end: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                    }>;

                                                                                                                                                                                                                                                                                                                                      variable IsInvisible

                                                                                                                                                                                                                                                                                                                                      const IsInvisible: string;

                                                                                                                                                                                                                                                                                                                                        variable MatchAny

                                                                                                                                                                                                                                                                                                                                        const MatchAny: string;
                                                                                                                                                                                                                                                                                                                                        • This file implements the DSL used by span and offset in places where they need to exhaustively consider all combinations of states (Handlebars offsets, character offsets and invisible/broken offsets).

                                                                                                                                                                                                                                                                                                                                          It's probably overkill, but it makes the code that uses it clear. It could be refactored or removed.

                                                                                                                                                                                                                                                                                                                                        variable NON_EXISTENT_LOCATION

                                                                                                                                                                                                                                                                                                                                        const NON_EXISTENT_LOCATION: Readonly<{
                                                                                                                                                                                                                                                                                                                                        readonly source: '(nonexistent)';
                                                                                                                                                                                                                                                                                                                                        readonly start: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                        readonly end: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                        }>;

                                                                                                                                                                                                                                                                                                                                          variable print

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

                                                                                                                                                                                                                                                                                                                                            variable publicBuilder

                                                                                                                                                                                                                                                                                                                                            const publicBuilder: {
                                                                                                                                                                                                                                                                                                                                            mustache: (
                                                                                                                                                                                                                                                                                                                                            path: Literal | BuilderHead,
                                                                                                                                                                                                                                                                                                                                            params?: Expression[],
                                                                                                                                                                                                                                                                                                                                            hash?: Hash,
                                                                                                                                                                                                                                                                                                                                            trusting?: boolean,
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation,
                                                                                                                                                                                                                                                                                                                                            strip?: StripFlags
                                                                                                                                                                                                                                                                                                                                            ) => MustacheStatement;
                                                                                                                                                                                                                                                                                                                                            block: (
                                                                                                                                                                                                                                                                                                                                            path: BuilderHead,
                                                                                                                                                                                                                                                                                                                                            params: Nullable<Expression[]>,
                                                                                                                                                                                                                                                                                                                                            hash: Nullable<Hash>,
                                                                                                                                                                                                                                                                                                                                            _defaultBlock: PossiblyDeprecatedBlock,
                                                                                                                                                                                                                                                                                                                                            _elseBlock?: Nullable<PossiblyDeprecatedBlock>,
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation,
                                                                                                                                                                                                                                                                                                                                            openStrip?: StripFlags,
                                                                                                                                                                                                                                                                                                                                            inverseStrip?: StripFlags,
                                                                                                                                                                                                                                                                                                                                            closeStrip?: StripFlags
                                                                                                                                                                                                                                                                                                                                            ) => BlockStatement;
                                                                                                                                                                                                                                                                                                                                            comment: (value: string, loc?: SourceLocation) => CommentStatement;
                                                                                                                                                                                                                                                                                                                                            mustacheComment: (
                                                                                                                                                                                                                                                                                                                                            value: string,
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => MustacheCommentStatement;
                                                                                                                                                                                                                                                                                                                                            element: (tag: TagDescriptor, options?: BuildElementOptions) => ElementNode;
                                                                                                                                                                                                                                                                                                                                            elementModifier: (
                                                                                                                                                                                                                                                                                                                                            path: BuilderHead,
                                                                                                                                                                                                                                                                                                                                            params?: Expression[],
                                                                                                                                                                                                                                                                                                                                            hash?: Hash,
                                                                                                                                                                                                                                                                                                                                            loc?: Nullable<SourceLocation>
                                                                                                                                                                                                                                                                                                                                            ) => ElementModifierStatement;
                                                                                                                                                                                                                                                                                                                                            attr: (name: string, value: AttrValue, loc?: SourceLocation) => AttrNode;
                                                                                                                                                                                                                                                                                                                                            text: (chars?: string, loc?: SourceLocation) => TextNode;
                                                                                                                                                                                                                                                                                                                                            sexpr: (
                                                                                                                                                                                                                                                                                                                                            path: BuilderHead,
                                                                                                                                                                                                                                                                                                                                            params?: Expression[],
                                                                                                                                                                                                                                                                                                                                            hash?: Hash,
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => SubExpression;
                                                                                                                                                                                                                                                                                                                                            concat: (
                                                                                                                                                                                                                                                                                                                                            parts: (MustacheStatement | TextNode)[],
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => ConcatStatement;
                                                                                                                                                                                                                                                                                                                                            hash: (pairs?: HashPair[], loc?: SourceLocation) => Hash;
                                                                                                                                                                                                                                                                                                                                            pair: (key: string, value: Expression, loc?: SourceLocation) => HashPair;
                                                                                                                                                                                                                                                                                                                                            literal: <T extends Literal>(
                                                                                                                                                                                                                                                                                                                                            type: T['type'],
                                                                                                                                                                                                                                                                                                                                            value: T['value'],
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => T;
                                                                                                                                                                                                                                                                                                                                            program: (
                                                                                                                                                                                                                                                                                                                                            body?: Statement[],
                                                                                                                                                                                                                                                                                                                                            blockParams?: string[],
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => Template | Block;
                                                                                                                                                                                                                                                                                                                                            blockItself: (
                                                                                                                                                                                                                                                                                                                                            body?: Statement[],
                                                                                                                                                                                                                                                                                                                                            params?: (string | VarHead)[],
                                                                                                                                                                                                                                                                                                                                            chained?: boolean,
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => Block;
                                                                                                                                                                                                                                                                                                                                            template: (
                                                                                                                                                                                                                                                                                                                                            body?: Statement[],
                                                                                                                                                                                                                                                                                                                                            blockParams?: string[],
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => Template;
                                                                                                                                                                                                                                                                                                                                            loc: {
                                                                                                                                                                                                                                                                                                                                            (loc: Nullable<SourceLocation>): SourceSpan;
                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                            startLine: number,
                                                                                                                                                                                                                                                                                                                                            startColumn: number,
                                                                                                                                                                                                                                                                                                                                            endLine?: number,
                                                                                                                                                                                                                                                                                                                                            endColumn?: number,
                                                                                                                                                                                                                                                                                                                                            source?: string
                                                                                                                                                                                                                                                                                                                                            ): SourceSpan;
                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                            pos: (line: number, column: number) => SourcePosition;
                                                                                                                                                                                                                                                                                                                                            path: {
                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                            path: string | PathExpression | { head: string; tail: string[] },
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ): PathExpression;
                                                                                                                                                                                                                                                                                                                                            (path: BuilderHead, loc?: SourceLocation): CallableExpression;
                                                                                                                                                                                                                                                                                                                                            (path: Literal | BuilderHead, loc?: SourceLocation): Expression;
                                                                                                                                                                                                                                                                                                                                            (path: Expression, loc?: SourceLocation): Expression;
                                                                                                                                                                                                                                                                                                                                            };
                                                                                                                                                                                                                                                                                                                                            fullPath: (
                                                                                                                                                                                                                                                                                                                                            head: PathHead,
                                                                                                                                                                                                                                                                                                                                            tail?: string[],
                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                            ) => PathExpression;
                                                                                                                                                                                                                                                                                                                                            head: (original: string, loc?: SourceLocation) => PathHead;
                                                                                                                                                                                                                                                                                                                                            at: (name: string, loc?: SourceLocation) => AtHead;
                                                                                                                                                                                                                                                                                                                                            var: (name: string, loc?: SourceLocation) => VarHead;
                                                                                                                                                                                                                                                                                                                                            this: (loc?: SourceLocation) => ThisHead;
                                                                                                                                                                                                                                                                                                                                            string: (value: string) => StringLiteral;
                                                                                                                                                                                                                                                                                                                                            boolean: (value: boolean) => BooleanLiteral;
                                                                                                                                                                                                                                                                                                                                            number: (value: number) => NumberLiteral;
                                                                                                                                                                                                                                                                                                                                            undefined(): UndefinedLiteral;
                                                                                                                                                                                                                                                                                                                                            null(): NullLiteral;
                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                              variable span

                                                                                                                                                                                                                                                                                                                                              const span: MatchFn<SourceSpan>;

                                                                                                                                                                                                                                                                                                                                                variable SYNTHETIC

                                                                                                                                                                                                                                                                                                                                                const SYNTHETIC: Readonly<{
                                                                                                                                                                                                                                                                                                                                                readonly source: '(synthetic)';
                                                                                                                                                                                                                                                                                                                                                readonly start: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                                readonly end: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                                }>;
                                                                                                                                                                                                                                                                                                                                                • Deprecated

                                                                                                                                                                                                                                                                                                                                                variable SYNTHETIC_LOCATION

                                                                                                                                                                                                                                                                                                                                                const SYNTHETIC_LOCATION: Readonly<{
                                                                                                                                                                                                                                                                                                                                                readonly source: '(synthetic)';
                                                                                                                                                                                                                                                                                                                                                readonly start: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                                readonly end: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                                }>;

                                                                                                                                                                                                                                                                                                                                                  variable TEMPORARY_LOCATION

                                                                                                                                                                                                                                                                                                                                                  const TEMPORARY_LOCATION: Readonly<{
                                                                                                                                                                                                                                                                                                                                                  readonly source: '(temporary)';
                                                                                                                                                                                                                                                                                                                                                  readonly start: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                                  readonly end: Readonly<{ readonly line: 1; readonly column: 0 }>;
                                                                                                                                                                                                                                                                                                                                                  }>;

                                                                                                                                                                                                                                                                                                                                                    variable UNKNOWN_POSITION

                                                                                                                                                                                                                                                                                                                                                    const UNKNOWN_POSITION: Readonly<{ readonly line: 1; readonly column: 0 }>;

                                                                                                                                                                                                                                                                                                                                                      variable visitorKeys

                                                                                                                                                                                                                                                                                                                                                      const visitorKeys: {
                                                                                                                                                                                                                                                                                                                                                      readonly Template: readonly ['body'];
                                                                                                                                                                                                                                                                                                                                                      readonly Block: readonly ['body'];
                                                                                                                                                                                                                                                                                                                                                      readonly MustacheStatement: readonly ['path', 'params', 'hash'];
                                                                                                                                                                                                                                                                                                                                                      readonly BlockStatement: readonly [
                                                                                                                                                                                                                                                                                                                                                      'path',
                                                                                                                                                                                                                                                                                                                                                      'params',
                                                                                                                                                                                                                                                                                                                                                      'hash',
                                                                                                                                                                                                                                                                                                                                                      'program',
                                                                                                                                                                                                                                                                                                                                                      'inverse'
                                                                                                                                                                                                                                                                                                                                                      ];
                                                                                                                                                                                                                                                                                                                                                      readonly ElementModifierStatement: readonly ['path', 'params', 'hash'];
                                                                                                                                                                                                                                                                                                                                                      readonly CommentStatement: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly MustacheCommentStatement: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly ElementNode: readonly [
                                                                                                                                                                                                                                                                                                                                                      'attributes',
                                                                                                                                                                                                                                                                                                                                                      'modifiers',
                                                                                                                                                                                                                                                                                                                                                      'children',
                                                                                                                                                                                                                                                                                                                                                      'comments'
                                                                                                                                                                                                                                                                                                                                                      ];
                                                                                                                                                                                                                                                                                                                                                      readonly AttrNode: readonly ['value'];
                                                                                                                                                                                                                                                                                                                                                      readonly TextNode: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly ConcatStatement: readonly ['parts'];
                                                                                                                                                                                                                                                                                                                                                      readonly SubExpression: readonly ['path', 'params', 'hash'];
                                                                                                                                                                                                                                                                                                                                                      readonly PathExpression: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly StringLiteral: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly BooleanLiteral: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly NumberLiteral: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly NullLiteral: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly UndefinedLiteral: readonly [];
                                                                                                                                                                                                                                                                                                                                                      readonly Hash: readonly ['pairs'];
                                                                                                                                                                                                                                                                                                                                                      readonly HashPair: readonly ['value'];
                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                        variable voidMap

                                                                                                                                                                                                                                                                                                                                                        const voidMap: Set<string>;

                                                                                                                                                                                                                                                                                                                                                          function build

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

                                                                                                                                                                                                                                                                                                                                                            function buildAtName

                                                                                                                                                                                                                                                                                                                                                            buildAtName: (name: string, loc?: SourceLocation) => ASTv1.AtHead;

                                                                                                                                                                                                                                                                                                                                                              function buildAttr

                                                                                                                                                                                                                                                                                                                                                              buildAttr: (
                                                                                                                                                                                                                                                                                                                                                              name: string,
                                                                                                                                                                                                                                                                                                                                                              value: ASTv1.AttrValue,
                                                                                                                                                                                                                                                                                                                                                              loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                              ) => ASTv1.AttrNode;

                                                                                                                                                                                                                                                                                                                                                                function buildBlock

                                                                                                                                                                                                                                                                                                                                                                buildBlock: (
                                                                                                                                                                                                                                                                                                                                                                path: BuilderHead,
                                                                                                                                                                                                                                                                                                                                                                params: Nullable<Expression[]>,
                                                                                                                                                                                                                                                                                                                                                                hash: Nullable<Hash>,
                                                                                                                                                                                                                                                                                                                                                                _defaultBlock: PossiblyDeprecatedBlock,
                                                                                                                                                                                                                                                                                                                                                                _elseBlock?: Nullable<PossiblyDeprecatedBlock>,
                                                                                                                                                                                                                                                                                                                                                                loc?: SourceLocation,
                                                                                                                                                                                                                                                                                                                                                                openStrip?: ASTv1.StripFlags,
                                                                                                                                                                                                                                                                                                                                                                inverseStrip?: ASTv1.StripFlags,
                                                                                                                                                                                                                                                                                                                                                                closeStrip?: ASTv1.StripFlags
                                                                                                                                                                                                                                                                                                                                                                ) => ASTv1.BlockStatement;

                                                                                                                                                                                                                                                                                                                                                                  function buildBlockItself

                                                                                                                                                                                                                                                                                                                                                                  buildBlockItself: (
                                                                                                                                                                                                                                                                                                                                                                  body?: ASTv1.Statement[],
                                                                                                                                                                                                                                                                                                                                                                  params?: Array<ASTv1.VarHead | string>,
                                                                                                                                                                                                                                                                                                                                                                  chained?: boolean,
                                                                                                                                                                                                                                                                                                                                                                  loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                  ) => ASTv1.Block;

                                                                                                                                                                                                                                                                                                                                                                    function buildCleanPath

                                                                                                                                                                                                                                                                                                                                                                    buildCleanPath: (
                                                                                                                                                                                                                                                                                                                                                                    head: ASTv1.PathHead,
                                                                                                                                                                                                                                                                                                                                                                    tail?: string[],
                                                                                                                                                                                                                                                                                                                                                                    loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                    ) => ASTv1.PathExpression;

                                                                                                                                                                                                                                                                                                                                                                      function buildComment

                                                                                                                                                                                                                                                                                                                                                                      buildComment: (value: string, loc?: SourceLocation) => ASTv1.CommentStatement;

                                                                                                                                                                                                                                                                                                                                                                        function buildConcat

                                                                                                                                                                                                                                                                                                                                                                        buildConcat: (
                                                                                                                                                                                                                                                                                                                                                                        parts: (ASTv1.TextNode | ASTv1.MustacheStatement)[],
                                                                                                                                                                                                                                                                                                                                                                        loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                        ) => ASTv1.ConcatStatement;

                                                                                                                                                                                                                                                                                                                                                                          function buildElement

                                                                                                                                                                                                                                                                                                                                                                          buildElement: (
                                                                                                                                                                                                                                                                                                                                                                          tag: TagDescriptor,
                                                                                                                                                                                                                                                                                                                                                                          options?: BuildElementOptions
                                                                                                                                                                                                                                                                                                                                                                          ) => ASTv1.ElementNode;

                                                                                                                                                                                                                                                                                                                                                                            function buildElementModifier

                                                                                                                                                                                                                                                                                                                                                                            buildElementModifier: (
                                                                                                                                                                                                                                                                                                                                                                            path: BuilderHead,
                                                                                                                                                                                                                                                                                                                                                                            params?: ASTv1.Expression[],
                                                                                                                                                                                                                                                                                                                                                                            hash?: ASTv1.Hash,
                                                                                                                                                                                                                                                                                                                                                                            loc?: Nullable<SourceLocation>
                                                                                                                                                                                                                                                                                                                                                                            ) => ASTv1.ElementModifierStatement;

                                                                                                                                                                                                                                                                                                                                                                              function buildHash

                                                                                                                                                                                                                                                                                                                                                                              buildHash: (pairs?: ASTv1.HashPair[], loc?: SourceLocation) => ASTv1.Hash;

                                                                                                                                                                                                                                                                                                                                                                                function buildHeadFromString

                                                                                                                                                                                                                                                                                                                                                                                buildHeadFromString: (original: string, loc?: SourceLocation) => ASTv1.PathHead;

                                                                                                                                                                                                                                                                                                                                                                                  function buildLiteral

                                                                                                                                                                                                                                                                                                                                                                                  buildLiteral: <T extends Literal>(
                                                                                                                                                                                                                                                                                                                                                                                  type: T['type'],
                                                                                                                                                                                                                                                                                                                                                                                  value: T['value'],
                                                                                                                                                                                                                                                                                                                                                                                  loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                                                                                                                                    function buildLoc

                                                                                                                                                                                                                                                                                                                                                                                    buildLoc: {
                                                                                                                                                                                                                                                                                                                                                                                    (loc: Nullable<SourceLocation>): SourceSpan;
                                                                                                                                                                                                                                                                                                                                                                                    (
                                                                                                                                                                                                                                                                                                                                                                                    startLine: number,
                                                                                                                                                                                                                                                                                                                                                                                    startColumn: number,
                                                                                                                                                                                                                                                                                                                                                                                    endLine?: number,
                                                                                                                                                                                                                                                                                                                                                                                    endColumn?: number,
                                                                                                                                                                                                                                                                                                                                                                                    source?: string
                                                                                                                                                                                                                                                                                                                                                                                    ): SourceSpan;
                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                      function buildMustache

                                                                                                                                                                                                                                                                                                                                                                                      buildMustache: (
                                                                                                                                                                                                                                                                                                                                                                                      path: BuilderHead | ASTv1.Literal,
                                                                                                                                                                                                                                                                                                                                                                                      params?: ASTv1.Expression[],
                                                                                                                                                                                                                                                                                                                                                                                      hash?: ASTv1.Hash,
                                                                                                                                                                                                                                                                                                                                                                                      trusting?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                      loc?: SourceLocation,
                                                                                                                                                                                                                                                                                                                                                                                      strip?: ASTv1.StripFlags
                                                                                                                                                                                                                                                                                                                                                                                      ) => ASTv1.MustacheStatement;

                                                                                                                                                                                                                                                                                                                                                                                        function buildMustacheComment

                                                                                                                                                                                                                                                                                                                                                                                        buildMustacheComment: (
                                                                                                                                                                                                                                                                                                                                                                                        value: string,
                                                                                                                                                                                                                                                                                                                                                                                        loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                        ) => ASTv1.MustacheCommentStatement;

                                                                                                                                                                                                                                                                                                                                                                                          function buildPair

                                                                                                                                                                                                                                                                                                                                                                                          buildPair: (
                                                                                                                                                                                                                                                                                                                                                                                          key: string,
                                                                                                                                                                                                                                                                                                                                                                                          value: ASTv1.Expression,
                                                                                                                                                                                                                                                                                                                                                                                          loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                          ) => ASTv1.HashPair;

                                                                                                                                                                                                                                                                                                                                                                                            function buildPath

                                                                                                                                                                                                                                                                                                                                                                                            buildPath: {
                                                                                                                                                                                                                                                                                                                                                                                            (
                                                                                                                                                                                                                                                                                                                                                                                            path: ASTv1.PathExpression | string | { head: string; tail: string[] },
                                                                                                                                                                                                                                                                                                                                                                                            loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                            ): ASTv1.PathExpression;
                                                                                                                                                                                                                                                                                                                                                                                            (path: BuilderHead, loc?: SourceLocation): CallableExpression;
                                                                                                                                                                                                                                                                                                                                                                                            (path: Literal | BuilderHead, loc?: SourceLocation): Expression;
                                                                                                                                                                                                                                                                                                                                                                                            (path: Expression, loc?: SourceLocation): Expression;
                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                              function buildPosition

                                                                                                                                                                                                                                                                                                                                                                                              buildPosition: (line: number, column: number) => SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                function buildProgram

                                                                                                                                                                                                                                                                                                                                                                                                buildProgram: (
                                                                                                                                                                                                                                                                                                                                                                                                body?: ASTv1.Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                blockParams?: string[],
                                                                                                                                                                                                                                                                                                                                                                                                loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                                ) => ASTv1.Template | ASTv1.Block;

                                                                                                                                                                                                                                                                                                                                                                                                  function buildSexpr

                                                                                                                                                                                                                                                                                                                                                                                                  buildSexpr: (
                                                                                                                                                                                                                                                                                                                                                                                                  path: BuilderHead,
                                                                                                                                                                                                                                                                                                                                                                                                  params?: ASTv1.Expression[],
                                                                                                                                                                                                                                                                                                                                                                                                  hash?: ASTv1.Hash,
                                                                                                                                                                                                                                                                                                                                                                                                  loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                                  ) => ASTv1.SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                    function buildTemplate

                                                                                                                                                                                                                                                                                                                                                                                                    buildTemplate: (
                                                                                                                                                                                                                                                                                                                                                                                                    body?: ASTv1.Statement[],
                                                                                                                                                                                                                                                                                                                                                                                                    blockParams?: string[],
                                                                                                                                                                                                                                                                                                                                                                                                    loc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                                    ) => ASTv1.Template;

                                                                                                                                                                                                                                                                                                                                                                                                      function buildText

                                                                                                                                                                                                                                                                                                                                                                                                      buildText: (chars?: string, loc?: SourceLocation) => ASTv1.TextNode;

                                                                                                                                                                                                                                                                                                                                                                                                        function buildThis

                                                                                                                                                                                                                                                                                                                                                                                                        buildThis: (loc?: SourceLocation) => ASTv1.ThisHead;

                                                                                                                                                                                                                                                                                                                                                                                                          function buildVar

                                                                                                                                                                                                                                                                                                                                                                                                          buildVar: (name: string, loc?: SourceLocation) => ASTv1.VarHead;

                                                                                                                                                                                                                                                                                                                                                                                                            function getVoidTags

                                                                                                                                                                                                                                                                                                                                                                                                            getVoidTags: () => string[];

                                                                                                                                                                                                                                                                                                                                                                                                              function hasSpan

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

                                                                                                                                                                                                                                                                                                                                                                                                                function isLocatedWithPositions

                                                                                                                                                                                                                                                                                                                                                                                                                isLocatedWithPositions: (
                                                                                                                                                                                                                                                                                                                                                                                                                location: LocatedWithOptionalPositions
                                                                                                                                                                                                                                                                                                                                                                                                                ) => location is LocatedWithPositions;

                                                                                                                                                                                                                                                                                                                                                                                                                  function isLocatedWithPositionsArray

                                                                                                                                                                                                                                                                                                                                                                                                                  isLocatedWithPositionsArray: (
                                                                                                                                                                                                                                                                                                                                                                                                                  location: LocatedWithOptionalPositions[]
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => location is PresentArray<LocatedWithPositions>;

                                                                                                                                                                                                                                                                                                                                                                                                                    function isVoidTag

                                                                                                                                                                                                                                                                                                                                                                                                                    isVoidTag: (tag: string) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                    • Examples when true: - link - liNK

                                                                                                                                                                                                                                                                                                                                                                                                                      Examples when false: - Link (component)

                                                                                                                                                                                                                                                                                                                                                                                                                    function loc

                                                                                                                                                                                                                                                                                                                                                                                                                    loc: (span: HasSourceSpan) => SourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                      function match

                                                                                                                                                                                                                                                                                                                                                                                                                      match: <Out>(
                                                                                                                                                                                                                                                                                                                                                                                                                      callback: (m: Matcher<Out, Matches>) => ExhaustiveMatcher<Out>
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => MatchFn<Out>;

                                                                                                                                                                                                                                                                                                                                                                                                                        function maybeLoc

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

                                                                                                                                                                                                                                                                                                                                                                                                                          function preprocess

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

                                                                                                                                                                                                                                                                                                                                                                                                                            function traverse

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

                                                                                                                                                                                                                                                                                                                                                                                                                              class CharPosition

                                                                                                                                                                                                                                                                                                                                                                                                                              class CharPosition implements PositionData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                constructor(source: Source, charPos: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                  property charPos

                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly charPos: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly offset: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                      • A CharPosition always has an offset it can produce without any additional computation.

                                                                                                                                                                                                                                                                                                                                                                                                                                      property source

                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly source: Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toCharPos

                                                                                                                                                                                                                                                                                                                                                                                                                                        toCharPos: () => CharPosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • This is already a CharPosition.

                                                                                                                                                                                                                                                                                                                                                                                                                                          for the alternative.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toHbsPos

                                                                                                                                                                                                                                                                                                                                                                                                                                        toHbsPos: () => HbsPosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Convert the current character offset to an HbsPosition, if it was not already computed. Once a CharPosition has computed its HbsPosition, it will not need to do compute it again, and the same CharPosition is retained when used as one of the ends of a SourceSpan, so computing the HbsPosition should be a one-time operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                        toJSON: () => SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                        • Produce a Handlebars for this CharPosition. If this CharPosition was computed using , this will compute the SourcePosition for the offset.

                                                                                                                                                                                                                                                                                                                                                                                                                                        method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                        wrap: () => SourceOffset;

                                                                                                                                                                                                                                                                                                                                                                                                                                          class CharPositionSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                          class CharPositionSpan implements SpanData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                            source: Source,
                                                                                                                                                                                                                                                                                                                                                                                                                                            charPositions: { start: CharPosition; end: CharPosition }
                                                                                                                                                                                                                                                                                                                                                                                                                                            );

                                                                                                                                                                                                                                                                                                                                                                                                                                              property charPositions

                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly charPositions: { start: CharPosition; end: CharPosition };

                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly kind: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly source: Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    method asString

                                                                                                                                                                                                                                                                                                                                                                                                                                                    asString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                      getEnd: () => AnyPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        method getModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                        getModule: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          method getStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                          getStart: () => AnyPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            method locDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                            locDidUpdate: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                              serialize: () => SerializedSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toCharPosSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                toCharPosSpan: () => CharPositionSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method toHbsSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  toHbsSpan: () => HbsSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    wrap: () => SourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class HandlebarsNodeVisitors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract class HandlebarsNodeVisitors extends Parser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pendingError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        protected pendingError: Nullable<PendingError>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method appendDynamicAttributeValuePart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          appendDynamicAttributeValuePart: (part: ASTv1.MustacheStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method appendToCommentData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract appendToCommentData: (s: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method beginAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract beginAttributeValue: (quoted: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BlockStatement: (block: HBS.BlockStatement) => ASTv1.BlockStatement | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BooleanLiteral: (boolean: HBS.BooleanLiteral) => ASTv1.BooleanLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CommentStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    rawComment: HBS.CommentStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Nullable<MustacheCommentStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ContentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ContentStatement: (content: HBS.ContentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method Decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Decorator: (decorator: HBS.Decorator) => never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method DecoratorBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DecoratorBlock: (decoratorBlock: HBS.DecoratorBlock) => never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method finalizeTextPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            finalizeTextPart: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method finishAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract finishAttributeValue: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Hash: (hash: HBS.Hash) => ASTv1.Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  MustacheStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  rawMustache: HBS.MustacheStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => ASTv1.MustacheStatement | void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    NullLiteral: (nul: HBS.NullLiteral) => ASTv1.NullLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      NumberLiteral: (number: HBS.NumberLiteral) => ASTv1.NumberLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        parse: (program: HBS.Program, blockParams: string[]) => ASTv1.Template;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          PartialBlockStatement: (partialBlock: HBS.PartialBlockStatement) => never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            PartialStatement: (partial: HBS.PartialStatement) => never;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PathExpression: (path: HBS.PathExpression) => ASTv1.PathExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Program: (program: HBS.Program, blockParams?: ASTv1.VarHead[]) => ASTv1.Block;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method startTextPart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  startTextPart: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StringLiteral: (string: HBS.StringLiteral) => ASTv1.StringLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SubExpression: (sexpr: HBS.SubExpression) => ASTv1.SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UndefinedLiteral: (undef: HBS.UndefinedLiteral) => ASTv1.UndefinedLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class HbsPosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          class HbsPosition implements PositionData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            constructor(source: Source, hbsPos: SourcePosition, charPos?: number);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hbsPos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly hbsPos: SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                readonly kind: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly source: Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toCharPos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toCharPos: () => CharPosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Lazily compute the character offset from the . Once an HbsPosition has computed its CharPosition, it will not need to do compute it again, and the same HbsPosition is retained when used as one of the ends of a SourceSpan, so computing the CharPosition should be a one-time operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toHbsPos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toHbsPos: () => HbsPosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • This is already an HbsPosition.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      for the alternative.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    toJSON: () => SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • Return the that this HbsPosition was instantiated with. This operation does not need to compute anything.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    wrap: () => SourceOffset;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class HbsSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      class HbsSpan implements SpanData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: Source,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hbsPositions: { start: HbsPosition; end: HbsPosition },
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        providedHbsLoc?: SourceLocation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property hbsPositions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly hbsPositions: { start: HbsPosition; end: HbsPosition };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly kind: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly source: Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method asString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                asString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method getEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  getEnd: () => AnyPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method getModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    getModule: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method getStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      getStart: () => AnyPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method locDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        locDidUpdate: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        start,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        start?: SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end?: SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          serialize: () => SerializedConcreteSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toCharPosSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toCharPosSpan: () => CharPositionSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toHbsLoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toHbsLoc: () => SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method toHbsSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                toHbsSpan: () => HbsSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  wrap: () => SourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class InvisiblePosition

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    class InvisiblePosition implements PositionData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      kind:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | OffsetKind.InternalsSynthetic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | OffsetKind.NonExistent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | OffsetKind.Broken,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pos: SourcePosition
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly kind:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | OffsetKind.InternalsSynthetic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | OffsetKind.NonExistent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | OffsetKind.Broken;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly offset: null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly pos: SourcePosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toCharPos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toCharPos: () => null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • A broken position cannot be turned into a .

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toJSON

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toJSON: () => SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • The serialization of an `InvisiblePosition is whatever Handlebars was originally identified as broken, non-existent or synthetic.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                If an InvisiblePosition never had an source offset at all, this method returns for compatibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              wrap: () => SourceOffset;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class InvisibleSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class InvisibleSpan implements SpanData {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  kind:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | OffsetKind.InternalsSynthetic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | OffsetKind.NonExistent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | OffsetKind.Broken,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  loc: SourceLocation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  string?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property kind

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly kind:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | OffsetKind.InternalsSynthetic
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | OffsetKind.NonExistent
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | OffsetKind.Broken;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly string: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method asString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          asString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method getEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            getEnd: () => AnyPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method getModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              getModule: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method getStart

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                getStart: () => AnyPosition;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method locDidUpdate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  locDidUpdate: ({
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start?: SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end?: SourcePosition;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method serialize

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    serialize: () => SerializedConcreteSourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method toCharPosSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toCharPosSpan: () => InvisibleSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method toHbsLoc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toHbsLoc: () => SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method toHbsSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          toHbsSpan: () => null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method wrap

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            wrap: () => SourceSpan;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Matcher

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              class Matcher<Out, M extends Matches = Matches> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method check

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                protected check: () => MatchFn<Out>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • You didn't exhaustively match all possibilities.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method when

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                when: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: OffsetKind.CharPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: OffsetKind.HbsPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: CharPosition, right: HbsPosition) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ExhaustiveCheck<Out, M, 'Char,Hbs'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: OffsetKind.HbsPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: OffsetKind.CharPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: HbsPosition, right: CharPosition) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ExhaustiveCheck<Out, M, 'Hbs,Char'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: OffsetKind.HbsPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: OffsetKind.HbsPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: HbsPosition, right: HbsPosition) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ExhaustiveCheck<Out, M, 'Hbs,Hbs'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: OffsetKind.CharPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: OffsetKind.CharPosition,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: CharPosition, right: CharPosition) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ExhaustiveCheck<Out, M, 'Char,Char'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: 'IS_INVISIBLE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: 'MATCH_ANY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: InvisiblePosition, right: PositionData) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): Matcher<Out, Exclude<M, 'Invisible,Any'>>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: 'MATCH_ANY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: 'IS_INVISIBLE',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: PositionData, right: InvisiblePosition) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ExhaustiveCheck<Out, M, 'Any,Invisible'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left: 'MATCH_ANY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right: 'MATCH_ANY',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                callback: (left: PositionData, right: PositionData) => Out
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): ExhaustiveMatcher<Out>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  class Parser

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract class Parser {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constructor(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    source: src.Source,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    entityParser?: EntityParser,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode?: 'precompile' | 'codemod'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    );

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property currentAttr

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      readonly currentAttr: Attribute;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property currentAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        currentAttribute: Nullable<Attribute>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property currentComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          readonly currentComment: ParserNodeBuilder<CommentStatement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property currentData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            readonly currentData: ParserNodeBuilder<TextNode>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property currentEndTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              readonly currentEndTag: ParserNodeBuilder<EndTag>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property currentNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                currentNode: Nullable<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Readonly<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ParserNodeBuilder<CommentStatement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ParserNodeBuilder<TextNode>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ParserNodeBuilder<StartTag>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | ParserNodeBuilder<EndTag>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property currentStartTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  readonly currentStartTag: ParserNodeBuilder<StartTag>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property currentTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    readonly currentTag: ParserNodeBuilder<StartTag> | ParserNodeBuilder<EndTag>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property elementStack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      protected elementStack: ParentNode[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        readonly source: src.Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property tokenizer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          tokenizer: EventedTokenizer;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method acceptNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            acceptNode: <T extends keyof HBS.NodeMap>(node: HBS.Node<T>) => HBS.Output<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method appendToAttributeName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract appendToAttributeName: (char: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method appendToAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract appendToAttributeValue: (char: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method appendToCommentData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract appendToCommentData: (char: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method appendToData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract appendToData: (char: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method appendToTagName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract appendToTagName: (char: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method beginAttribute

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract beginAttribute: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method beginAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract beginAttributeValue: (quoted: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method beginComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract beginComment: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method beginData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract beginData: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method beginEndTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract beginEndTag: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method beginStartTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract beginStartTag: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract BlockStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: HBS.BlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => HBS.Output<'BlockStatement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract BooleanLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: HBS.BooleanLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => HBS.Output<'BooleanLiteral'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract CommentStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: HBS.CommentStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => HBS.Output<'CommentStatement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method ContentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract ContentStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: HBS.ContentStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => HBS.Output<'ContentStatement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method currentElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            currentElement: () => ASTv1.ParentNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method Decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract Decorator: (node: HBS.Decorator) => HBS.Output<'Decorator'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method DecoratorBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract DecoratorBlock: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: HBS.DecoratorBlock
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => HBS.Output<'DecoratorBlock'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method finish

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  finish: <T extends { loc: src.SourceSpan }>(node: ParserNodeBuilder<T>) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method finishAttributeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract finishAttributeValue: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method finishComment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract finishComment: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method finishData

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract finishData: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method finishTag

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract finishTag: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method markTagAsSelfClosing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract markTagAsSelfClosing: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract MustacheStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: HBS.MustacheStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => HBS.Output<'MustacheStatement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract NullLiteral: (node: HBS.NullLiteral) => HBS.Output<'NullLiteral'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract NumberLiteral: (node: HBS.NumberLiteral) => HBS.Output<'NumberLiteral'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    offset: () => src.SourceOffset;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      abstract parse: (node: HBS.Program, locals: string[]) => ASTv1.Template;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract PartialBlockStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: HBS.PartialBlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => HBS.Output<'PartialBlockStatement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract PartialStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: HBS.PartialStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => HBS.Output<'PartialStatement'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract PathExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: HBS.PathExpression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => HBS.Output<'PathExpression'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method pos

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pos: ({ line, column }: src.SourcePosition) => src.SourceOffset;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                abstract Program: (node: HBS.Program) => HBS.Output<'Program'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method reportSyntaxError

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  abstract reportSyntaxError: (error: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method reset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    abstract reset: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method sourceForNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      sourceForNode: (node: HBS.Node, endNode?: { loc: HBS.SourceLocation }) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        abstract StringLiteral: (node: HBS.StringLiteral) => HBS.Output<'StringLiteral'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          abstract SubExpression: (node: HBS.SubExpression) => HBS.Output<'SubExpression'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method tagOpen

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            abstract tagOpen: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              abstract UndefinedLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: HBS.UndefinedLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => HBS.Output<'UndefinedLiteral'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Printer

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Printer {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(options: PrinterOptions);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method AttrNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AttrNode: (attr: ASTv1.AttrNode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method AttrNodeValue

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AttrNodeValue: (value: ASTv1.AttrNode['value']) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method Block

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Block: (block: ASTv1.Block) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method BlockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BlockParams: (blockParams: string[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            BlockStatement: (block: ASTv1.BlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              BooleanLiteral: (bool: ASTv1.BooleanLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method CloseElementNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                CloseElementNode: (el: ASTv1.ElementNode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CommentStatement: (comment: ASTv1.CommentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method ConcatStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ConcatStatement: (concat: ASTv1.ConcatStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ElementModifierStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ElementModifierStatement: (mod: ASTv1.ElementModifierStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method ElementNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ElementNode: (el: ASTv1.ElementNode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Expression: (expression: ASTv1.Expression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method handledByOverride

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            handledByOverride: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: ASTv1.Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ensureLeadingWhitespace?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Hash: (hash: ASTv1.Hash) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method HashPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                HashPair: (pair: ASTv1.HashPair) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Literal: (literal: ASTv1.Literal) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method MustacheCommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    MustacheCommentStatement: (comment: ASTv1.MustacheCommentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MustacheStatement: (mustache: ASTv1.MustacheStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Node: (node: ASTv1.Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NullLiteral: (node: ASTv1.NullLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            NumberLiteral: (number: ASTv1.NumberLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method OpenElementNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              OpenElementNode: (el: ASTv1.ElementNode) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method Params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Params: (params: ASTv1.Expression[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  PathExpression: (path: ASTv1.PathExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method print

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    print: (node: ASTv1.Node) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      StringLiteral: (str: ASTv1.StringLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SubExpression: (sexp: ASTv1.SubExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method Template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Template: (template: ASTv1.Template) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method TextNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TextNode: (text: ASTv1.TextNode, isAttr?: boolean) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method TopLevelStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              TopLevelStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              statement: ASTv1.TopLevelStatement | ASTv1.Template | ASTv1.AttrNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method TopLevelStatements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TopLevelStatements: (statements: ASTv1.TopLevelStatement[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  UndefinedLiteral: (node: ASTv1.UndefinedLiteral) => 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 from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              static from: (source: string, options?: PrecompileOptions) => Source;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method hbsPosFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hbsPosFor: (offset: number) => Nullable<SourcePosition>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method offsetFor

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method slice

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method spanFor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      spanFor: (