handlebars

  • Version 4.7.7
  • Published
  • 2.72 MB
  • 5 dependencies
  • MIT license

Install

npm i handlebars
yarn add handlebars
pnpm add handlebars

Overview

Handlebars provides the power necessary to let you build semantic templates effectively with no frustration

Index

Namespaces

Namespaces

namespace handlebars

module 'handlebars' {}

    variable decorators

    const decorators: { [name: string]: Function };

      variable escapeExpression

      const escapeExpression: (str: string) => string;

        variable helpers

        const helpers: { [name: string]: HelperDelegate };

          variable logger

          const logger: Logger;

            variable partials

            const partials: { [name: string]: any };

              variable templates

              const templates: HandlebarsTemplates;

                variable VERSION

                const VERSION: string;

                  function blockParams

                  blockParams: (obj: any[], ids: any[]) => any[];

                    function compile

                    compile: <T = any>(
                    input: any,
                    options?: CompileOptions
                    ) => HandlebarsTemplateDelegate<T>;

                      function create

                      create: () => typeof Handlebars;

                        function createFrame

                        createFrame: (object: any) => any;

                          function K

                          K: () => void;

                            function log

                            log: (level: number, obj: any) => void;

                              function noConflict

                              noConflict: () => typeof Handlebars;

                                function parse

                                parse: (input: string, options?: ParseOptions) => hbs.AST.Program;

                                  function parseWithoutProcessing

                                  parseWithoutProcessing: (
                                  input: string,
                                  options?: ParseOptions
                                  ) => hbs.AST.Program;

                                    function precompile

                                    precompile: (input: any, options?: PrecompileOptions) => TemplateSpecification;

                                      function registerDecorator

                                      registerDecorator: (name: string, fn: Function) => void;

                                        function registerHelper

                                        registerHelper: {
                                        (name: string, fn: HelperDelegate): void;
                                        (name: HelperDeclareSpec): void;
                                        };

                                          function registerPartial

                                          registerPartial: {
                                          (name: string, fn: Template): void;
                                          (spec: { [name: string]: HandlebarsTemplateDelegate<any> }): void;
                                          };

                                            function template

                                            template: <T = any>(
                                            precompilation: TemplateSpecification
                                            ) => HandlebarsTemplateDelegate<T>;

                                              function unregisterDecorator

                                              unregisterDecorator: (name: string) => void;

                                                function unregisterHelper

                                                unregisterHelper: (name: string) => void;

                                                  function unregisterPartial

                                                  unregisterPartial: (name: string) => void;

                                                    class Exception

                                                    class Exception {}

                                                      constructor

                                                      constructor(message: string, node?: hbs.AST.Node);

                                                        property column

                                                        column?: any;

                                                          property description

                                                          description: string;

                                                            property endColumn

                                                            endColumn?: any;

                                                              property endLineNumber

                                                              endLineNumber?: any;

                                                                property fileName

                                                                fileName: string;

                                                                  property lineNumber

                                                                  lineNumber?: any;

                                                                    property message

                                                                    message: string;

                                                                      property name

                                                                      name: string;

                                                                        property number

                                                                        number: number;

                                                                          property stack

                                                                          stack?: string;

                                                                            class SafeString

                                                                            class SafeString {}

                                                                              constructor

                                                                              constructor(str: string);

                                                                                method toHTML

                                                                                toHTML: () => string;

                                                                                  method toString

                                                                                  toString: () => string;

                                                                                    class Visitor

                                                                                    class Visitor implements ICompiler {}

                                                                                      method accept

                                                                                      accept: (node: hbs.AST.Node) => void;

                                                                                        method acceptArray

                                                                                        acceptArray: (arr: hbs.AST.Expression[]) => void;

                                                                                          method acceptKey

                                                                                          acceptKey: (node: hbs.AST.Node, name: string) => void;

                                                                                            method BlockStatement

                                                                                            BlockStatement: (block: hbs.AST.BlockStatement) => void;

                                                                                              method BooleanLiteral

                                                                                              BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

                                                                                                method CommentStatement

                                                                                                CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

                                                                                                  method ContentStatement

                                                                                                  ContentStatement: (content: hbs.AST.ContentStatement) => void;

                                                                                                    method Decorator

                                                                                                    Decorator: (decorator: hbs.AST.Decorator) => void;

                                                                                                      method DecoratorBlock

                                                                                                      DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

                                                                                                        method Hash

                                                                                                        Hash: (hash: hbs.AST.Hash) => void;

                                                                                                          method MustacheStatement

                                                                                                          MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

                                                                                                            method NullLiteral

                                                                                                            NullLiteral: () => void;

                                                                                                              method NumberLiteral

                                                                                                              NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

                                                                                                                method PartialBlockStatement

                                                                                                                PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

                                                                                                                  method PartialStatement

                                                                                                                  PartialStatement: (partial: hbs.AST.PartialStatement) => void;

                                                                                                                    method PathExpression

                                                                                                                    PathExpression: (path: hbs.AST.PathExpression) => void;

                                                                                                                      method Program

                                                                                                                      Program: (program: hbs.AST.Program) => void;

                                                                                                                        method StringLiteral

                                                                                                                        StringLiteral: (str: hbs.AST.StringLiteral) => void;

                                                                                                                          method SubExpression

                                                                                                                          SubExpression: (sexpr: hbs.AST.SubExpression) => void;

                                                                                                                            method UndefinedLiteral

                                                                                                                            UndefinedLiteral: () => void;

                                                                                                                              interface HelperDeclareSpec

                                                                                                                              interface HelperDeclareSpec {}

                                                                                                                                index signature

                                                                                                                                [key: string]: HelperDelegate;

                                                                                                                                  interface HelperDelegate

                                                                                                                                  interface HelperDelegate {}

                                                                                                                                    call signature

                                                                                                                                    (
                                                                                                                                    context?: any,
                                                                                                                                    arg1?: any,
                                                                                                                                    arg2?: any,
                                                                                                                                    arg3?: any,
                                                                                                                                    arg4?: any,
                                                                                                                                    arg5?: any,
                                                                                                                                    options?: HelperOptions
                                                                                                                                    ): any;

                                                                                                                                      interface HelperOptions

                                                                                                                                      interface HelperOptions {}

                                                                                                                                        property data

                                                                                                                                        data?: any;

                                                                                                                                          property fn

                                                                                                                                          fn: TemplateDelegate;

                                                                                                                                            property hash

                                                                                                                                            hash: any;

                                                                                                                                              property inverse

                                                                                                                                              inverse: TemplateDelegate;

                                                                                                                                                interface ICompiler

                                                                                                                                                interface ICompiler {}

                                                                                                                                                  method accept

                                                                                                                                                  accept: (node: hbs.AST.Node) => void;

                                                                                                                                                    method BlockStatement

                                                                                                                                                    BlockStatement: (block: hbs.AST.BlockStatement) => void;

                                                                                                                                                      method BooleanLiteral

                                                                                                                                                      BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

                                                                                                                                                        method CommentStatement

                                                                                                                                                        CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

                                                                                                                                                          method ContentStatement

                                                                                                                                                          ContentStatement: (content: hbs.AST.ContentStatement) => void;

                                                                                                                                                            method Decorator

                                                                                                                                                            Decorator: (decorator: hbs.AST.Decorator) => void;

                                                                                                                                                              method DecoratorBlock

                                                                                                                                                              DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

                                                                                                                                                                method Hash

                                                                                                                                                                Hash: (hash: hbs.AST.Hash) => void;

                                                                                                                                                                  method MustacheStatement

                                                                                                                                                                  MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

                                                                                                                                                                    method NullLiteral

                                                                                                                                                                    NullLiteral: () => void;

                                                                                                                                                                      method NumberLiteral

                                                                                                                                                                      NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

                                                                                                                                                                        method PartialBlockStatement

                                                                                                                                                                        PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

                                                                                                                                                                          method PartialStatement

                                                                                                                                                                          PartialStatement: (partial: hbs.AST.PartialStatement) => void;

                                                                                                                                                                            method PathExpression

                                                                                                                                                                            PathExpression: (path: hbs.AST.PathExpression) => void;

                                                                                                                                                                              method Program

                                                                                                                                                                              Program: (program: hbs.AST.Program) => void;

                                                                                                                                                                                method StringLiteral

                                                                                                                                                                                StringLiteral: (str: hbs.AST.StringLiteral) => void;

                                                                                                                                                                                  method SubExpression

                                                                                                                                                                                  SubExpression: (sexpr: hbs.AST.SubExpression) => void;

                                                                                                                                                                                    method UndefinedLiteral

                                                                                                                                                                                    UndefinedLiteral: () => void;

                                                                                                                                                                                      interface ParseOptions

                                                                                                                                                                                      interface ParseOptions {}

                                                                                                                                                                                        property ignoreStandalone

                                                                                                                                                                                        ignoreStandalone?: boolean;

                                                                                                                                                                                          property srcName

                                                                                                                                                                                          srcName?: string;

                                                                                                                                                                                            interface ResolvePartialOptions

                                                                                                                                                                                            interface ResolvePartialOptions {}

                                                                                                                                                                                              property data

                                                                                                                                                                                              data?: any;

                                                                                                                                                                                                property decorators

                                                                                                                                                                                                decorators?: { [name: string]: Function };

                                                                                                                                                                                                  property helpers

                                                                                                                                                                                                  helpers?: { [name: string]: Function };

                                                                                                                                                                                                    property name

                                                                                                                                                                                                    name: string;

                                                                                                                                                                                                      property partials

                                                                                                                                                                                                      partials?: { [name: string]: HandlebarsTemplateDelegate };

                                                                                                                                                                                                        interface RuntimeOptions

                                                                                                                                                                                                        interface RuntimeOptions {}

                                                                                                                                                                                                          property allowCallsToHelperMissing

                                                                                                                                                                                                          allowCallsToHelperMissing?: boolean;

                                                                                                                                                                                                            property allowedProtoMethods

                                                                                                                                                                                                            allowedProtoMethods?: { [name: string]: boolean };

                                                                                                                                                                                                              property allowedProtoProperties

                                                                                                                                                                                                              allowedProtoProperties?: { [name: string]: boolean };

                                                                                                                                                                                                                property allowProtoMethodsByDefault

                                                                                                                                                                                                                allowProtoMethodsByDefault?: boolean;

                                                                                                                                                                                                                  property allowProtoPropertiesByDefault

                                                                                                                                                                                                                  allowProtoPropertiesByDefault?: boolean;

                                                                                                                                                                                                                    property blockParams

                                                                                                                                                                                                                    blockParams?: any[];

                                                                                                                                                                                                                      property data

                                                                                                                                                                                                                      data?: any;

                                                                                                                                                                                                                        property decorators

                                                                                                                                                                                                                        decorators?: { [name: string]: Function };

                                                                                                                                                                                                                          property depths

                                                                                                                                                                                                                          depths?: any[];

                                                                                                                                                                                                                            property helpers

                                                                                                                                                                                                                            helpers?: { [name: string]: Function };

                                                                                                                                                                                                                              property partial

                                                                                                                                                                                                                              partial?: boolean;

                                                                                                                                                                                                                                property partials

                                                                                                                                                                                                                                partials?: { [name: string]: HandlebarsTemplateDelegate };

                                                                                                                                                                                                                                  interface TemplateDelegate

                                                                                                                                                                                                                                  interface TemplateDelegate<T = any> {}

                                                                                                                                                                                                                                    call signature

                                                                                                                                                                                                                                    (context: T, options?: RuntimeOptions): string;

                                                                                                                                                                                                                                      type Template

                                                                                                                                                                                                                                      type Template<T = any> = TemplateDelegate<T> | string;

                                                                                                                                                                                                                                        namespace Handlebars

                                                                                                                                                                                                                                        namespace Handlebars {}

                                                                                                                                                                                                                                          variable decorators

                                                                                                                                                                                                                                          const decorators: { [name: string]: Function };

                                                                                                                                                                                                                                            variable escapeExpression

                                                                                                                                                                                                                                            const escapeExpression: (str: string) => string;

                                                                                                                                                                                                                                              variable helpers

                                                                                                                                                                                                                                              const helpers: { [name: string]: HelperDelegate };

                                                                                                                                                                                                                                                variable logger

                                                                                                                                                                                                                                                const logger: Logger;

                                                                                                                                                                                                                                                  variable partials

                                                                                                                                                                                                                                                  const partials: { [name: string]: any };

                                                                                                                                                                                                                                                    variable templates

                                                                                                                                                                                                                                                    const templates: HandlebarsTemplates;

                                                                                                                                                                                                                                                      variable VERSION

                                                                                                                                                                                                                                                      const VERSION: string;

                                                                                                                                                                                                                                                        function blockParams

                                                                                                                                                                                                                                                        blockParams: (obj: any[], ids: any[]) => any[];

                                                                                                                                                                                                                                                          function compile

                                                                                                                                                                                                                                                          compile: <T = any>(
                                                                                                                                                                                                                                                          input: any,
                                                                                                                                                                                                                                                          options?: CompileOptions
                                                                                                                                                                                                                                                          ) => HandlebarsTemplateDelegate<T>;

                                                                                                                                                                                                                                                            function create

                                                                                                                                                                                                                                                            create: () => typeof Handlebars;

                                                                                                                                                                                                                                                              function createFrame

                                                                                                                                                                                                                                                              createFrame: (object: any) => any;

                                                                                                                                                                                                                                                                function K

                                                                                                                                                                                                                                                                K: () => void;

                                                                                                                                                                                                                                                                  function log

                                                                                                                                                                                                                                                                  log: (level: number, obj: any) => void;

                                                                                                                                                                                                                                                                    function noConflict

                                                                                                                                                                                                                                                                    noConflict: () => typeof Handlebars;

                                                                                                                                                                                                                                                                      function parse

                                                                                                                                                                                                                                                                      parse: (input: string, options?: ParseOptions) => hbs.AST.Program;

                                                                                                                                                                                                                                                                        function parseWithoutProcessing

                                                                                                                                                                                                                                                                        parseWithoutProcessing: (
                                                                                                                                                                                                                                                                        input: string,
                                                                                                                                                                                                                                                                        options?: ParseOptions
                                                                                                                                                                                                                                                                        ) => hbs.AST.Program;

                                                                                                                                                                                                                                                                          function precompile

                                                                                                                                                                                                                                                                          precompile: (input: any, options?: PrecompileOptions) => TemplateSpecification;

                                                                                                                                                                                                                                                                            function registerDecorator

                                                                                                                                                                                                                                                                            registerDecorator: (name: string, fn: Function) => void;

                                                                                                                                                                                                                                                                              function registerHelper

                                                                                                                                                                                                                                                                              registerHelper: {
                                                                                                                                                                                                                                                                              (name: string, fn: HelperDelegate): void;
                                                                                                                                                                                                                                                                              (name: HelperDeclareSpec): void;
                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                function registerPartial

                                                                                                                                                                                                                                                                                registerPartial: {
                                                                                                                                                                                                                                                                                (name: string, fn: Template): void;
                                                                                                                                                                                                                                                                                (spec: { [name: string]: HandlebarsTemplateDelegate<any> }): void;
                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                  function template

                                                                                                                                                                                                                                                                                  template: <T = any>(
                                                                                                                                                                                                                                                                                  precompilation: TemplateSpecification
                                                                                                                                                                                                                                                                                  ) => HandlebarsTemplateDelegate<T>;

                                                                                                                                                                                                                                                                                    function unregisterDecorator

                                                                                                                                                                                                                                                                                    unregisterDecorator: (name: string) => void;

                                                                                                                                                                                                                                                                                      function unregisterHelper

                                                                                                                                                                                                                                                                                      unregisterHelper: (name: string) => void;

                                                                                                                                                                                                                                                                                        function unregisterPartial

                                                                                                                                                                                                                                                                                        unregisterPartial: (name: string) => void;

                                                                                                                                                                                                                                                                                          class Exception

                                                                                                                                                                                                                                                                                          class Exception {}

                                                                                                                                                                                                                                                                                            constructor

                                                                                                                                                                                                                                                                                            constructor(message: string, node?: hbs.AST.Node);

                                                                                                                                                                                                                                                                                              property column

                                                                                                                                                                                                                                                                                              column?: any;

                                                                                                                                                                                                                                                                                                property description

                                                                                                                                                                                                                                                                                                description: string;

                                                                                                                                                                                                                                                                                                  property endColumn

                                                                                                                                                                                                                                                                                                  endColumn?: any;

                                                                                                                                                                                                                                                                                                    property endLineNumber

                                                                                                                                                                                                                                                                                                    endLineNumber?: any;

                                                                                                                                                                                                                                                                                                      property fileName

                                                                                                                                                                                                                                                                                                      fileName: string;

                                                                                                                                                                                                                                                                                                        property lineNumber

                                                                                                                                                                                                                                                                                                        lineNumber?: any;

                                                                                                                                                                                                                                                                                                          property message

                                                                                                                                                                                                                                                                                                          message: string;

                                                                                                                                                                                                                                                                                                            property name

                                                                                                                                                                                                                                                                                                            name: string;

                                                                                                                                                                                                                                                                                                              property number

                                                                                                                                                                                                                                                                                                              number: number;

                                                                                                                                                                                                                                                                                                                property stack

                                                                                                                                                                                                                                                                                                                stack?: string;

                                                                                                                                                                                                                                                                                                                  class SafeString

                                                                                                                                                                                                                                                                                                                  class SafeString {}

                                                                                                                                                                                                                                                                                                                    constructor

                                                                                                                                                                                                                                                                                                                    constructor(str: string);

                                                                                                                                                                                                                                                                                                                      method toHTML

                                                                                                                                                                                                                                                                                                                      toHTML: () => string;

                                                                                                                                                                                                                                                                                                                        method toString

                                                                                                                                                                                                                                                                                                                        toString: () => string;

                                                                                                                                                                                                                                                                                                                          class Visitor

                                                                                                                                                                                                                                                                                                                          class Visitor implements ICompiler {}

                                                                                                                                                                                                                                                                                                                            method accept

                                                                                                                                                                                                                                                                                                                            accept: (node: hbs.AST.Node) => void;

                                                                                                                                                                                                                                                                                                                              method acceptArray

                                                                                                                                                                                                                                                                                                                              acceptArray: (arr: hbs.AST.Expression[]) => void;

                                                                                                                                                                                                                                                                                                                                method acceptKey

                                                                                                                                                                                                                                                                                                                                acceptKey: (node: hbs.AST.Node, name: string) => void;

                                                                                                                                                                                                                                                                                                                                  method BlockStatement

                                                                                                                                                                                                                                                                                                                                  BlockStatement: (block: hbs.AST.BlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                    method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                    BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

                                                                                                                                                                                                                                                                                                                                      method CommentStatement

                                                                                                                                                                                                                                                                                                                                      CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

                                                                                                                                                                                                                                                                                                                                        method ContentStatement

                                                                                                                                                                                                                                                                                                                                        ContentStatement: (content: hbs.AST.ContentStatement) => void;

                                                                                                                                                                                                                                                                                                                                          method Decorator

                                                                                                                                                                                                                                                                                                                                          Decorator: (decorator: hbs.AST.Decorator) => void;

                                                                                                                                                                                                                                                                                                                                            method DecoratorBlock

                                                                                                                                                                                                                                                                                                                                            DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

                                                                                                                                                                                                                                                                                                                                              method Hash

                                                                                                                                                                                                                                                                                                                                              Hash: (hash: hbs.AST.Hash) => void;

                                                                                                                                                                                                                                                                                                                                                method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

                                                                                                                                                                                                                                                                                                                                                  method NullLiteral

                                                                                                                                                                                                                                                                                                                                                  NullLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                    method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                    NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                      method PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                      PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                        method PartialStatement

                                                                                                                                                                                                                                                                                                                                                        PartialStatement: (partial: hbs.AST.PartialStatement) => void;

                                                                                                                                                                                                                                                                                                                                                          method PathExpression

                                                                                                                                                                                                                                                                                                                                                          PathExpression: (path: hbs.AST.PathExpression) => void;

                                                                                                                                                                                                                                                                                                                                                            method Program

                                                                                                                                                                                                                                                                                                                                                            Program: (program: hbs.AST.Program) => void;

                                                                                                                                                                                                                                                                                                                                                              method StringLiteral

                                                                                                                                                                                                                                                                                                                                                              StringLiteral: (str: hbs.AST.StringLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                method SubExpression

                                                                                                                                                                                                                                                                                                                                                                SubExpression: (sexpr: hbs.AST.SubExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                  method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                  UndefinedLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                    interface HelperDeclareSpec

                                                                                                                                                                                                                                                                                                                                                                    interface HelperDeclareSpec {}

                                                                                                                                                                                                                                                                                                                                                                      index signature

                                                                                                                                                                                                                                                                                                                                                                      [key: string]: HelperDelegate;

                                                                                                                                                                                                                                                                                                                                                                        interface HelperDelegate

                                                                                                                                                                                                                                                                                                                                                                        interface HelperDelegate {}

                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                          (
                                                                                                                                                                                                                                                                                                                                                                          context?: any,
                                                                                                                                                                                                                                                                                                                                                                          arg1?: any,
                                                                                                                                                                                                                                                                                                                                                                          arg2?: any,
                                                                                                                                                                                                                                                                                                                                                                          arg3?: any,
                                                                                                                                                                                                                                                                                                                                                                          arg4?: any,
                                                                                                                                                                                                                                                                                                                                                                          arg5?: any,
                                                                                                                                                                                                                                                                                                                                                                          options?: HelperOptions
                                                                                                                                                                                                                                                                                                                                                                          ): any;

                                                                                                                                                                                                                                                                                                                                                                            interface HelperOptions

                                                                                                                                                                                                                                                                                                                                                                            interface HelperOptions {}

                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                              data?: any;

                                                                                                                                                                                                                                                                                                                                                                                property fn

                                                                                                                                                                                                                                                                                                                                                                                fn: TemplateDelegate;

                                                                                                                                                                                                                                                                                                                                                                                  property hash

                                                                                                                                                                                                                                                                                                                                                                                  hash: any;

                                                                                                                                                                                                                                                                                                                                                                                    property inverse

                                                                                                                                                                                                                                                                                                                                                                                    inverse: TemplateDelegate;

                                                                                                                                                                                                                                                                                                                                                                                      interface ICompiler

                                                                                                                                                                                                                                                                                                                                                                                      interface ICompiler {}

                                                                                                                                                                                                                                                                                                                                                                                        method accept

                                                                                                                                                                                                                                                                                                                                                                                        accept: (node: hbs.AST.Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                          method BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                          BlockStatement: (block: hbs.AST.BlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                            method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                            BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                              method CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                              CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                method ContentStatement

                                                                                                                                                                                                                                                                                                                                                                                                ContentStatement: (content: hbs.AST.ContentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  method Decorator

                                                                                                                                                                                                                                                                                                                                                                                                  Decorator: (decorator: hbs.AST.Decorator) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    method DecoratorBlock

                                                                                                                                                                                                                                                                                                                                                                                                    DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

                                                                                                                                                                                                                                                                                                                                                                                                      method Hash

                                                                                                                                                                                                                                                                                                                                                                                                      Hash: (hash: hbs.AST.Hash) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                        MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          method NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                          NullLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                            method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                            NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              method PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                              PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                method PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                PartialStatement: (partial: hbs.AST.PartialStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  method PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                  PathExpression: (path: hbs.AST.PathExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    method Program

                                                                                                                                                                                                                                                                                                                                                                                                                    Program: (program: hbs.AST.Program) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      method StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                      StringLiteral: (str: hbs.AST.StringLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        method SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                        SubExpression: (sexpr: hbs.AST.SubExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                          UndefinedLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface ParseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                            interface ParseOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property ignoreStandalone

                                                                                                                                                                                                                                                                                                                                                                                                                              ignoreStandalone?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                property srcName

                                                                                                                                                                                                                                                                                                                                                                                                                                srcName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResolvePartialOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ResolvePartialOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                    data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                      property decorators

                                                                                                                                                                                                                                                                                                                                                                                                                                      decorators?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                        property helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                        helpers?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                          property name

                                                                                                                                                                                                                                                                                                                                                                                                                                          name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            property partials

                                                                                                                                                                                                                                                                                                                                                                                                                                            partials?: { [name: string]: HandlebarsTemplateDelegate };

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface RuntimeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property allowCallsToHelperMissing

                                                                                                                                                                                                                                                                                                                                                                                                                                                allowCallsToHelperMissing?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property allowedProtoMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                  allowedProtoMethods?: { [name: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                    property allowedProtoProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                    allowedProtoProperties?: { [name: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowProtoMethodsByDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                      allowProtoMethodsByDefault?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property allowProtoPropertiesByDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                        allowProtoPropertiesByDefault?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                          blockParams?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                            data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property decorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                              decorators?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property depths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                depths?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  helpers?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property partial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    partial?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property partials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      partials?: { [name: string]: HandlebarsTemplateDelegate };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TemplateDelegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface TemplateDelegate<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          (context: T, options?: RuntimeOptions): string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Template<T = any> = TemplateDelegate<T> | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace handlebars.AST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace handlebars.AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const helpers: hbs.AST.helpers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace Handlebars.AST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace Handlebars.AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const helpers: hbs.AST.helpers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace handlebars.Utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      namespace handlebars.Utils {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        blockParams: (obj: any[], ids: any[]) => any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function createFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          createFrame: (object: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function escapeExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            escapeExpression: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function extend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extend: (obj: any, ...source: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isArray: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isEmpty: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isFunction: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      toString: (obj: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace Handlebars.Utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace Handlebars.Utils {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          blockParams: (obj: any[], ids: any[]) => any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function createFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createFrame: (object: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function escapeExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              escapeExpression: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function extend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extend: (obj: any, ...source: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isArray: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEmpty: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFunction: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toString: (obj: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace handlebars.VM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace handlebars.VM {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function resolvePartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolvePartial: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            partial: HandlebarsTemplateDelegate<T> | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options: ResolvePartialOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => HandlebarsTemplateDelegate<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace Handlebars.VM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace Handlebars.VM {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function resolvePartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              resolvePartial: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              partial: HandlebarsTemplateDelegate<T> | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              context: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options: ResolvePartialOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => HandlebarsTemplateDelegate<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              namespace handlebars/runtime

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              module 'handlebars/runtime' {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable decorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const decorators: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable escapeExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const escapeExpression: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const helpers: { [name: string]: HelperDelegate };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable logger

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const logger: Logger;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable partials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const partials: { [name: string]: any };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable templates

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const templates: HandlebarsTemplates;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable VERSION

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const VERSION: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              blockParams: (obj: any[], ids: any[]) => any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function compile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                compile: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                input: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: CompileOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => HandlebarsTemplateDelegate<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function create

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  create: () => typeof Handlebars;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function createFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    createFrame: (object: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function K

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      K: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function log

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        log: (level: number, obj: any) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function noConflict

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          noConflict: () => typeof Handlebars;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function parse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            parse: (input: string, options?: ParseOptions) => hbs.AST.Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function parseWithoutProcessing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parseWithoutProcessing: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              input: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: ParseOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => hbs.AST.Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function precompile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                precompile: (input: any, options?: PrecompileOptions) => TemplateSpecification;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function registerDecorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  registerDecorator: (name: string, fn: Function) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function registerHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    registerHelper: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (name: string, fn: HelperDelegate): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    (name: HelperDeclareSpec): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function registerPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      registerPartial: {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (name: string, fn: Template): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (spec: { [name: string]: HandlebarsTemplateDelegate<any> }): void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        template: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        precompilation: TemplateSpecification
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => HandlebarsTemplateDelegate<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function unregisterDecorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unregisterDecorator: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function unregisterHelper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            unregisterHelper: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function unregisterPartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              unregisterPartial: (name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Exception

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Exception {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constructor(message: string, node?: hbs.AST.Node);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    column?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property description

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      description: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property endColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        endColumn?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property endLineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          endLineNumber?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property fileName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            fileName: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property lineNumber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              lineNumber?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property message

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                message: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property number

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    number: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property stack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      stack?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SafeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        class SafeString {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constructor(str: string);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method toHTML

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            toHTML: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              toString: () => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Visitor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                class Visitor implements ICompiler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method accept

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  accept: (node: hbs.AST.Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method acceptArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    acceptArray: (arr: hbs.AST.Expression[]) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method acceptKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      acceptKey: (node: hbs.AST.Node, name: string) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BlockStatement: (block: hbs.AST.BlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method ContentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ContentStatement: (content: hbs.AST.ContentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method Decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Decorator: (decorator: hbs.AST.Decorator) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method DecoratorBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Hash: (hash: hbs.AST.Hash) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        NullLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              PartialStatement: (partial: hbs.AST.PartialStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                PathExpression: (path: hbs.AST.PathExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Program: (program: hbs.AST.Program) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    StringLiteral: (str: hbs.AST.StringLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      SubExpression: (sexpr: hbs.AST.SubExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        UndefinedLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface HelperDeclareSpec

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface HelperDeclareSpec {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            index signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [key: string]: HelperDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HelperDelegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface HelperDelegate {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                context?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arg1?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arg2?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arg3?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arg4?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                arg5?: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: HelperOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ): any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface HelperOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface HelperOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property fn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      fn: TemplateDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hash: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inverse: TemplateDelegate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ICompiler

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ICompiler {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method accept

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              accept: (node: hbs.AST.Node) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                BlockStatement: (block: hbs.AST.BlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  BooleanLiteral: (bool: hbs.AST.BooleanLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    CommentStatement: (comment?: hbs.AST.CommentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method ContentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ContentStatement: (content: hbs.AST.ContentStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method Decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Decorator: (decorator: hbs.AST.Decorator) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method DecoratorBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DecoratorBlock: (decorator: hbs.AST.DecoratorBlock) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Hash: (hash: hbs.AST.Hash) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              MustacheStatement: (mustache: hbs.AST.MustacheStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                NullLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  NumberLiteral: (num: hbs.AST.NumberLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PartialBlockStatement: (partial: hbs.AST.PartialBlockStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      PartialStatement: (partial: hbs.AST.PartialStatement) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        PathExpression: (path: hbs.AST.PathExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Program: (program: hbs.AST.Program) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            method StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            StringLiteral: (str: hbs.AST.StringLiteral) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              method SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SubExpression: (sexpr: hbs.AST.SubExpression) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                UndefinedLiteral: () => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ParseOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface ParseOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property ignoreStandalone

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ignoreStandalone?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property srcName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      srcName?: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResolvePartialOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ResolvePartialOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property decorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            decorators?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              helpers?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property partials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  partials?: { [name: string]: HandlebarsTemplateDelegate };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuntimeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface RuntimeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property allowCallsToHelperMissing

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      allowCallsToHelperMissing?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property allowedProtoMethods

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        allowedProtoMethods?: { [name: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property allowedProtoProperties

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          allowedProtoProperties?: { [name: string]: boolean };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property allowProtoMethodsByDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            allowProtoMethodsByDefault?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property allowProtoPropertiesByDefault

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              allowProtoPropertiesByDefault?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                blockParams?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  data?: any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property decorators

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    decorators?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property depths

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      depths?: any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        helpers?: { [name: string]: Function };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property partial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          partial?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property partials

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            partials?: { [name: string]: HandlebarsTemplateDelegate };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TemplateDelegate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface TemplateDelegate<T = any> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                call signature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                (context: T, options?: RuntimeOptions): string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Template

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Template<T = any> = TemplateDelegate<T> | string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace handlebars/runtime.AST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    namespace handlebars/runtime.AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const helpers: hbs.AST.helpers;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace handlebars/runtime.Utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        namespace handlebars/runtime.Utils {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          blockParams: (obj: any[], ids: any[]) => any[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function createFrame

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            createFrame: (object: any) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function escapeExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              escapeExpression: (str: string) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function extend

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extend: (obj: any, ...source: any[]) => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isArray

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isArray: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isEmpty: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isFunction: (obj: any) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function toString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        toString: (obj: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace handlebars/runtime.VM

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          namespace handlebars/runtime.VM {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function resolvePartial

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            resolvePartial: <T = any>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            partial: HandlebarsTemplateDelegate<T> | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            context: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            options: ResolvePartialOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => HandlebarsTemplateDelegate<T>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace hbs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            namespace hbs {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SafeString

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type SafeString = Handlebars.SafeString;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Utils

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Utils = typeof Handlebars.Utils;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace hbs.AST

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  namespace hbs.AST {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface BlockStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property closeStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      closeStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property inverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          inverse: Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property inverseStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            inverseStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property openStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              openStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: PathExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    program: Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'BlockStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface BooleanLiteral extends Literal {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          original: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'BooleanLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface CommentStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'CommentStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ContentStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface ContentStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          original: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'ContentStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface Decorator extends MustacheStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DecoratorBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface DecoratorBlock extends BlockStatement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface Expression extends Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface Hash extends Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property pairs

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        pairs: HashPair[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'Hash';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface HashPair

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface HashPair extends Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property key

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              key: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'HashPair';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface helpers

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface helpers {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method helperExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      helperExpression: (node: Node) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        method scopeId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        scopeId: (path: PathExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          method simpleId

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          simpleId: (path: PathExpression) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Literal extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MustacheStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface MustacheStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property escaped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                escaped: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: PathExpression | Literal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'MustacheStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property loc

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              loc: SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NullLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NullLiteral extends Literal {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'NullLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NumberLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface NumberLiteral extends Literal {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        original: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'NumberLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            value: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PartialBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PartialBlockStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property closeStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                closeStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: PathExpression | SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property openStrip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      openStrip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          program: Program;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'PartialBlockStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PartialStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PartialStatement extends Statement {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property indent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  indent: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    name: PathExpression | SubExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property strip

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'PartialStatement';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PathExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PathExpression extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property data

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              data: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                depth: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property parts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    parts: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'PathExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Position

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface Position {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          column: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property line

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            line: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Program

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Program extends Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property blockParams

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                blockParams: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property body

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  body: Statement[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      end: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property source

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          start: Position;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface Statement extends Node {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface StringLiteral extends Literal {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                original: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'StringLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StripFlags

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface StripFlags {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property close

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        close: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property open

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          open: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface SubExpression extends Expression {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hash

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property params

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: PathExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'SubExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface UndefinedLiteral extends Literal {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'UndefinedLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Package Files (1)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dependencies (5)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Dev Dependencies (43)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Badge

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/handlebars)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • HTML
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <a href="https://www.jsdocs.io/package/handlebars"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>