@glimmer/syntax

  • Version 0.56.2
  • Published
  • 1.49 MB
  • 4 dependencies
  • MIT license

Install

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

Overview

Overview not available.

Index

Variables

variable builders

const builders: {
mustache: typeof buildMustache;
block: typeof buildBlock;
partial: typeof buildPartial;
comment: typeof buildComment;
mustacheComment: typeof buildMustacheComment;
element: typeof buildElement;
elementModifier: typeof buildElementModifier;
attr: typeof buildAttr;
text: typeof buildText;
sexpr: typeof buildSexpr;
path: typeof buildHead;
concat: typeof buildConcat;
hash: typeof buildHash;
pair: typeof buildPair;
literal: typeof buildLiteral;
program: typeof buildProgram;
blockItself: typeof buildBlockItself;
template: typeof buildTemplate;
loc: typeof buildLoc;
pos: typeof buildPosition;
string: (value: string) => StringLiteral;
boolean: (value: boolean) => BooleanLiteral;
number: (value: number) => NumberLiteral;
undefined(): AST.Literal;
null(): AST.Literal;
};

    variable SyntaxError

    const SyntaxError: SyntaxErrorConstructor;
    • Subclass of Error with additional information about location of incorrect markup.

    variable TraversalError

    const TraversalError: TraversalErrorConstructor;

      Functions

      function cannotRemoveNode

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

        function cannotReplaceNode

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

          function cannotReplaceOrRemoveInKeyHandlerYet

          cannotReplaceOrRemoveInKeyHandlerYet: (
          node: AST.Node,
          key: string
          ) => TraversalError;

            function isLiteral

            isLiteral: {
            (path: HBS.Expression): path is HBS.Literal;
            (path: AST.Expression): path is AST.Literal;
            };

              function preprocess

              preprocess: (html: string, options?: PreprocessOptions) => AST.Template;

                function print

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

                  function printLiteral

                  printLiteral: (literal: AST.Literal) => string;

                    function sortByLoc

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

                      function traverse

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

                        Classes

                        class Path

                        class Path<N extends Node> {}

                          constructor

                          constructor(node: Node, parent?: Path<Node>, parentKey?: string);

                            property node

                            node: Node;

                              property parent

                              parent: Path<Node>;

                                property parentKey

                                parentKey: string;

                                  property parentNode

                                  readonly parentNode: Node;

                                    method parents

                                    parents: () => Iterable<Path<Node> | null>;

                                      class Walker

                                      class Walker {}

                                        constructor

                                        constructor(order?: any);

                                          property order

                                          order?: any;

                                            property stack

                                            stack: any[];

                                              method children

                                              children: (node: any, callback: any) => void;

                                                method visit

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

                                                  Interfaces

                                                  interface ASTPlugin

                                                  interface ASTPlugin {}

                                                    property name

                                                    name: string;

                                                      property visitor

                                                      visitor: NodeVisitor;

                                                        interface ASTPluginBuilder

                                                        interface ASTPluginBuilder {}
                                                        • ASTPlugins can make changes to the Glimmer template AST before compilation begins.

                                                        call signature

                                                        (env: ASTPluginEnvironment): ASTPlugin;

                                                          interface ASTPluginEnvironment

                                                          interface ASTPluginEnvironment {}

                                                            property meta

                                                            meta?: object;

                                                              property syntax

                                                              syntax: Syntax;

                                                                interface FullKeyTraversal

                                                                interface FullKeyTraversal<N extends AST.Node, K extends string> {}

                                                                  method enter

                                                                  enter: (node: N, key: K) => void;

                                                                    method exit

                                                                    exit: (node: N, key: K) => void;

                                                                      interface FullNodeTraversal

                                                                      interface FullNodeTraversal<N extends AST.Node> {}

                                                                        property keys

                                                                        keys?: KeysVisitor<N>;

                                                                          method enter

                                                                          enter: (node: N, path: Path<N>) => void;

                                                                            method exit

                                                                            exit: (node: N, path: Path<N>) => void;

                                                                              interface PreprocessOptions

                                                                              interface PreprocessOptions {}

                                                                                property meta

                                                                                meta?: unknown;

                                                                                  property mode

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

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

                                                                                  property parseOptions

                                                                                  parseOptions?: HandlebarsParseOptions;

                                                                                    property plugins

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

                                                                                      interface Syntax

                                                                                      interface Syntax {}

                                                                                        property builders

                                                                                        builders: typeof builders;

                                                                                          property parse

                                                                                          parse: typeof preprocess;

                                                                                            property print

                                                                                            print: typeof print;

                                                                                              property traverse

                                                                                              traverse: typeof traverse;

                                                                                                property Walker

                                                                                                Walker: typeof Walker;

                                                                                                  interface SyntaxError

                                                                                                  interface SyntaxError extends Error {}

                                                                                                    property constructor

                                                                                                    constructor: SyntaxErrorConstructor;

                                                                                                      property location

                                                                                                      location: AST.SourceLocation;

                                                                                                        interface TraversalError

                                                                                                        interface TraversalError extends Error {}

                                                                                                          property constructor

                                                                                                          constructor: TraversalErrorConstructor;

                                                                                                            property key

                                                                                                            key: string;

                                                                                                              property node

                                                                                                              node: AST.Node;

                                                                                                                property parent

                                                                                                                parent: Option<AST.Node>;

                                                                                                                  Type Aliases

                                                                                                                  type KeyHandler

                                                                                                                  type KeyHandler<N extends AST.Node, K extends VisitorKey<N>> = (
                                                                                                                  node: N,
                                                                                                                  key: K
                                                                                                                  ) => void;

                                                                                                                    type KeysVisitor

                                                                                                                    type KeysVisitor<N extends AST.Node> = {
                                                                                                                    [P in VisitorKey<N>]?: KeyTraversal<N, P>;
                                                                                                                    } & {
                                                                                                                    All?: KeyTraversal<N, VisitorKey<N>>;
                                                                                                                    };

                                                                                                                      type KeyTraversal

                                                                                                                      type KeyTraversal<N extends AST.Node, K extends VisitorKey<N>> =
                                                                                                                      | FullKeyTraversal<N, K>
                                                                                                                      | KeyHandler<N, K>;

                                                                                                                        type NodeHandler

                                                                                                                        type NodeHandler<N extends AST.Node> = (node: N, path: Path<N>) => void;

                                                                                                                          type NodeTraversal

                                                                                                                          type NodeTraversal<N extends AST.Node> = FullNodeTraversal<N> | NodeHandler<N>;

                                                                                                                            type NodeVisitor

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

                                                                                                                              Namespaces

                                                                                                                              namespace AST

                                                                                                                              module 'dist/types/lib/types/nodes.d.ts' {}
                                                                                                                              • >= 1

                                                                                                                              interface AttrNode

                                                                                                                              interface AttrNode extends BaseNode {}

                                                                                                                                property name

                                                                                                                                name: string;

                                                                                                                                  property type

                                                                                                                                  type: 'AttrNode';

                                                                                                                                    property value

                                                                                                                                    value: TextNode | MustacheStatement | ConcatStatement;

                                                                                                                                      interface BaseNode

                                                                                                                                      interface BaseNode {}

                                                                                                                                        property loc

                                                                                                                                        loc: SourceLocation;

                                                                                                                                          property type

                                                                                                                                          type: NodeType;

                                                                                                                                            interface Block

                                                                                                                                            interface Block extends CommonProgram {}

                                                                                                                                              property symbols

                                                                                                                                              symbols?: BlockSymbols;

                                                                                                                                                property type

                                                                                                                                                type: 'Block';

                                                                                                                                                  interface BlockStatement

                                                                                                                                                  interface BlockStatement extends BaseNode {}

                                                                                                                                                    property chained

                                                                                                                                                    chained?: boolean;

                                                                                                                                                      property closeStrip

                                                                                                                                                      closeStrip: StripFlags;

                                                                                                                                                        property hash

                                                                                                                                                        hash: Hash;

                                                                                                                                                          property inverse

                                                                                                                                                          inverse?: Option<Block>;

                                                                                                                                                            property inverseStrip

                                                                                                                                                            inverseStrip: StripFlags;

                                                                                                                                                              property openStrip

                                                                                                                                                              openStrip: StripFlags;

                                                                                                                                                                property params

                                                                                                                                                                params: Expression[];

                                                                                                                                                                  property path

                                                                                                                                                                  path: Expression;

                                                                                                                                                                    property program

                                                                                                                                                                    program: Block;

                                                                                                                                                                      property symbols

                                                                                                                                                                      symbols?: BlockSymbols;

                                                                                                                                                                        property type

                                                                                                                                                                        type: 'BlockStatement';

                                                                                                                                                                          interface BlockSymbols

                                                                                                                                                                          interface BlockSymbols extends Symbols {}

                                                                                                                                                                            property slots

                                                                                                                                                                            slots: number[];

                                                                                                                                                                              interface BooleanLiteral

                                                                                                                                                                              interface BooleanLiteral extends BaseNode {}

                                                                                                                                                                                property original

                                                                                                                                                                                original: boolean;

                                                                                                                                                                                  property type

                                                                                                                                                                                  type: 'BooleanLiteral';

                                                                                                                                                                                    property value

                                                                                                                                                                                    value: boolean;

                                                                                                                                                                                      interface Call

                                                                                                                                                                                      interface Call extends BaseNode {}

                                                                                                                                                                                        property hash

                                                                                                                                                                                        hash: Hash;

                                                                                                                                                                                          property name

                                                                                                                                                                                          name?: Expression;

                                                                                                                                                                                            property params

                                                                                                                                                                                            params: Expression[];

                                                                                                                                                                                              property path

                                                                                                                                                                                              path: Expression;

                                                                                                                                                                                                interface CommentStatement

                                                                                                                                                                                                interface CommentStatement extends BaseNode {}

                                                                                                                                                                                                  property type

                                                                                                                                                                                                  type: 'CommentStatement';

                                                                                                                                                                                                    property value

                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                      interface CommonProgram

                                                                                                                                                                                                      interface CommonProgram extends BaseNode {}

                                                                                                                                                                                                        property blockParams

                                                                                                                                                                                                        blockParams: string[];

                                                                                                                                                                                                          property body

                                                                                                                                                                                                          body: TopLevelStatement[];

                                                                                                                                                                                                            property chained

                                                                                                                                                                                                            chained?: boolean;

                                                                                                                                                                                                              interface ConcatStatement

                                                                                                                                                                                                              interface ConcatStatement extends BaseNode {}

                                                                                                                                                                                                                property parts

                                                                                                                                                                                                                parts: (TextNode | MustacheStatement)[];

                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                  type: 'ConcatStatement';

                                                                                                                                                                                                                    interface ElementModifierStatement

                                                                                                                                                                                                                    interface ElementModifierStatement extends BaseNode {}

                                                                                                                                                                                                                      property hash

                                                                                                                                                                                                                      hash: Hash;

                                                                                                                                                                                                                        property params

                                                                                                                                                                                                                        params: Expression[];

                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                          path: Expression;

                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                            type: 'ElementModifierStatement';

                                                                                                                                                                                                                              interface ElementNode

                                                                                                                                                                                                                              interface ElementNode extends BaseNode {}

                                                                                                                                                                                                                                property attributes

                                                                                                                                                                                                                                attributes: AttrNode[];

                                                                                                                                                                                                                                  property blockParams

                                                                                                                                                                                                                                  blockParams: string[];

                                                                                                                                                                                                                                    property children

                                                                                                                                                                                                                                    children: TopLevelStatement[];

                                                                                                                                                                                                                                      property comments

                                                                                                                                                                                                                                      comments: MustacheCommentStatement[];

                                                                                                                                                                                                                                        property modifiers

                                                                                                                                                                                                                                        modifiers: ElementModifierStatement[];

                                                                                                                                                                                                                                          property selfClosing

                                                                                                                                                                                                                                          selfClosing: boolean;

                                                                                                                                                                                                                                            property symbols

                                                                                                                                                                                                                                            symbols?: BlockSymbols;

                                                                                                                                                                                                                                              property tag

                                                                                                                                                                                                                                              tag: string;

                                                                                                                                                                                                                                                property type

                                                                                                                                                                                                                                                type: 'ElementNode';

                                                                                                                                                                                                                                                  interface Hash

                                                                                                                                                                                                                                                  interface Hash extends BaseNode {}

                                                                                                                                                                                                                                                    property pairs

                                                                                                                                                                                                                                                    pairs: HashPair[];

                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                      type: 'Hash';

                                                                                                                                                                                                                                                        interface HashPair

                                                                                                                                                                                                                                                        interface HashPair extends BaseNode {}

                                                                                                                                                                                                                                                          property key

                                                                                                                                                                                                                                                          key: string;

                                                                                                                                                                                                                                                            property type

                                                                                                                                                                                                                                                            type: 'HashPair';

                                                                                                                                                                                                                                                              property value

                                                                                                                                                                                                                                                              value: Expression;

                                                                                                                                                                                                                                                                interface MustacheCommentStatement

                                                                                                                                                                                                                                                                interface MustacheCommentStatement extends BaseNode {}

                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                  type: 'MustacheCommentStatement';

                                                                                                                                                                                                                                                                    property value

                                                                                                                                                                                                                                                                    value: string;

                                                                                                                                                                                                                                                                      interface MustacheStatement

                                                                                                                                                                                                                                                                      interface MustacheStatement extends BaseNode {}

                                                                                                                                                                                                                                                                        property escaped

                                                                                                                                                                                                                                                                        escaped: boolean;

                                                                                                                                                                                                                                                                          property hash

                                                                                                                                                                                                                                                                          hash: Hash;

                                                                                                                                                                                                                                                                            property params

                                                                                                                                                                                                                                                                            params: Expression[];

                                                                                                                                                                                                                                                                              property path

                                                                                                                                                                                                                                                                              path: Expression;

                                                                                                                                                                                                                                                                                property strip

                                                                                                                                                                                                                                                                                strip: StripFlags;

                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                  type: 'MustacheStatement';

                                                                                                                                                                                                                                                                                    interface Nodes

                                                                                                                                                                                                                                                                                    interface Nodes {}

                                                                                                                                                                                                                                                                                      property AttrNode

                                                                                                                                                                                                                                                                                      AttrNode: AttrNode;

                                                                                                                                                                                                                                                                                        property Block

                                                                                                                                                                                                                                                                                        Block: Block;

                                                                                                                                                                                                                                                                                          property BlockStatement

                                                                                                                                                                                                                                                                                          BlockStatement: BlockStatement;

                                                                                                                                                                                                                                                                                            property BooleanLiteral

                                                                                                                                                                                                                                                                                            BooleanLiteral: BooleanLiteral;

                                                                                                                                                                                                                                                                                              property CommentStatement

                                                                                                                                                                                                                                                                                              CommentStatement: CommentStatement;

                                                                                                                                                                                                                                                                                                property ConcatStatement

                                                                                                                                                                                                                                                                                                ConcatStatement: ConcatStatement;

                                                                                                                                                                                                                                                                                                  property ElementModifierStatement

                                                                                                                                                                                                                                                                                                  ElementModifierStatement: ElementModifierStatement;

                                                                                                                                                                                                                                                                                                    property ElementNode

                                                                                                                                                                                                                                                                                                    ElementNode: ElementNode;

                                                                                                                                                                                                                                                                                                      property Hash

                                                                                                                                                                                                                                                                                                      Hash: Hash;

                                                                                                                                                                                                                                                                                                        property HashPair

                                                                                                                                                                                                                                                                                                        HashPair: HashPair;

                                                                                                                                                                                                                                                                                                          property MustacheCommentStatement

                                                                                                                                                                                                                                                                                                          MustacheCommentStatement: MustacheCommentStatement;

                                                                                                                                                                                                                                                                                                            property MustacheStatement

                                                                                                                                                                                                                                                                                                            MustacheStatement: MustacheStatement;

                                                                                                                                                                                                                                                                                                              property NullLiteral

                                                                                                                                                                                                                                                                                                              NullLiteral: NullLiteral;

                                                                                                                                                                                                                                                                                                                property NumberLiteral

                                                                                                                                                                                                                                                                                                                NumberLiteral: NumberLiteral;

                                                                                                                                                                                                                                                                                                                  property PartialStatement

                                                                                                                                                                                                                                                                                                                  PartialStatement: PartialStatement;

                                                                                                                                                                                                                                                                                                                    property PathExpression

                                                                                                                                                                                                                                                                                                                    PathExpression: PathExpression;

                                                                                                                                                                                                                                                                                                                      property Program

                                                                                                                                                                                                                                                                                                                      Program: Program;

                                                                                                                                                                                                                                                                                                                        property StringLiteral

                                                                                                                                                                                                                                                                                                                        StringLiteral: StringLiteral;

                                                                                                                                                                                                                                                                                                                          property SubExpression

                                                                                                                                                                                                                                                                                                                          SubExpression: SubExpression;

                                                                                                                                                                                                                                                                                                                            property Template

                                                                                                                                                                                                                                                                                                                            Template: Template;

                                                                                                                                                                                                                                                                                                                              property TextNode

                                                                                                                                                                                                                                                                                                                              TextNode: TextNode;

                                                                                                                                                                                                                                                                                                                                property UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                UndefinedLiteral: UndefinedLiteral;

                                                                                                                                                                                                                                                                                                                                  interface NullLiteral

                                                                                                                                                                                                                                                                                                                                  interface NullLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                    property original

                                                                                                                                                                                                                                                                                                                                    original: null;

                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                      type: 'NullLiteral';

                                                                                                                                                                                                                                                                                                                                        property value

                                                                                                                                                                                                                                                                                                                                        value: null;

                                                                                                                                                                                                                                                                                                                                          interface NumberLiteral

                                                                                                                                                                                                                                                                                                                                          interface NumberLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                            property original

                                                                                                                                                                                                                                                                                                                                            original: number;

                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                              type: 'NumberLiteral';

                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                value: number;

                                                                                                                                                                                                                                                                                                                                                  interface PartialStatement

                                                                                                                                                                                                                                                                                                                                                  interface PartialStatement extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                    property hash

                                                                                                                                                                                                                                                                                                                                                    hash: Hash;

                                                                                                                                                                                                                                                                                                                                                      property indent

                                                                                                                                                                                                                                                                                                                                                      indent: string;

                                                                                                                                                                                                                                                                                                                                                        property name

                                                                                                                                                                                                                                                                                                                                                        name: PathExpression | SubExpression;

                                                                                                                                                                                                                                                                                                                                                          property params

                                                                                                                                                                                                                                                                                                                                                          params: Expression[];

                                                                                                                                                                                                                                                                                                                                                            property strip

                                                                                                                                                                                                                                                                                                                                                            strip: StripFlags;

                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                              type: 'PartialStatement';

                                                                                                                                                                                                                                                                                                                                                                interface PathExpression

                                                                                                                                                                                                                                                                                                                                                                interface PathExpression extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                  property data

                                                                                                                                                                                                                                                                                                                                                                  data: boolean;

                                                                                                                                                                                                                                                                                                                                                                    property original

                                                                                                                                                                                                                                                                                                                                                                    original: string;

                                                                                                                                                                                                                                                                                                                                                                      property parts

                                                                                                                                                                                                                                                                                                                                                                      parts: string[];

                                                                                                                                                                                                                                                                                                                                                                        property this

                                                                                                                                                                                                                                                                                                                                                                        this: boolean;

                                                                                                                                                                                                                                                                                                                                                                          property type

                                                                                                                                                                                                                                                                                                                                                                          type: 'PathExpression';

                                                                                                                                                                                                                                                                                                                                                                            interface Position

                                                                                                                                                                                                                                                                                                                                                                            interface Position {}

                                                                                                                                                                                                                                                                                                                                                                              property column

                                                                                                                                                                                                                                                                                                                                                                              column: number;
                                                                                                                                                                                                                                                                                                                                                                              • >= 0

                                                                                                                                                                                                                                                                                                                                                                              property line

                                                                                                                                                                                                                                                                                                                                                                              line: number;
                                                                                                                                                                                                                                                                                                                                                                              • >= 1

                                                                                                                                                                                                                                                                                                                                                                              interface Program

                                                                                                                                                                                                                                                                                                                                                                              interface Program extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                property symbols

                                                                                                                                                                                                                                                                                                                                                                                symbols?: Symbols;

                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                  type: 'Program';

                                                                                                                                                                                                                                                                                                                                                                                    interface ProgramSymbols

                                                                                                                                                                                                                                                                                                                                                                                    interface ProgramSymbols extends Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                      property freeVariables

                                                                                                                                                                                                                                                                                                                                                                                      freeVariables: string[];

                                                                                                                                                                                                                                                                                                                                                                                        interface SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                        interface SourceLocation {}

                                                                                                                                                                                                                                                                                                                                                                                          property end

                                                                                                                                                                                                                                                                                                                                                                                          end: Position;

                                                                                                                                                                                                                                                                                                                                                                                            property source

                                                                                                                                                                                                                                                                                                                                                                                            source?: Option<string>;

                                                                                                                                                                                                                                                                                                                                                                                              property start

                                                                                                                                                                                                                                                                                                                                                                                              start: Position;

                                                                                                                                                                                                                                                                                                                                                                                                interface StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                interface StringLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                  property original

                                                                                                                                                                                                                                                                                                                                                                                                  original: string;

                                                                                                                                                                                                                                                                                                                                                                                                    property type

                                                                                                                                                                                                                                                                                                                                                                                                    type: 'StringLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                      property value

                                                                                                                                                                                                                                                                                                                                                                                                      value: string;

                                                                                                                                                                                                                                                                                                                                                                                                        interface StripFlags

                                                                                                                                                                                                                                                                                                                                                                                                        interface StripFlags {}

                                                                                                                                                                                                                                                                                                                                                                                                          property close

                                                                                                                                                                                                                                                                                                                                                                                                          close: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                            property open

                                                                                                                                                                                                                                                                                                                                                                                                            open: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                              interface SubExpression

                                                                                                                                                                                                                                                                                                                                                                                                              interface SubExpression extends Call {}

                                                                                                                                                                                                                                                                                                                                                                                                                property hash

                                                                                                                                                                                                                                                                                                                                                                                                                hash: Hash;

                                                                                                                                                                                                                                                                                                                                                                                                                  property params

                                                                                                                                                                                                                                                                                                                                                                                                                  params: Expression[];

                                                                                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                                                                                    path: Expression;

                                                                                                                                                                                                                                                                                                                                                                                                                      property type

                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'SubExpression';

                                                                                                                                                                                                                                                                                                                                                                                                                        interface Symbols

                                                                                                                                                                                                                                                                                                                                                                                                                        interface Symbols {}

                                                                                                                                                                                                                                                                                                                                                                                                                          property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                          symbols: string[];

                                                                                                                                                                                                                                                                                                                                                                                                                            method allocate

                                                                                                                                                                                                                                                                                                                                                                                                                            allocate: (identifier: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                              method allocateBlock

                                                                                                                                                                                                                                                                                                                                                                                                                              allocateBlock: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                method allocateFree

                                                                                                                                                                                                                                                                                                                                                                                                                                allocateFree: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                  method allocateNamed

                                                                                                                                                                                                                                                                                                                                                                                                                                  allocateNamed: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                    method child

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      method get

                                                                                                                                                                                                                                                                                                                                                                                                                                      get: (name: string) => number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        method getEvalInfo

                                                                                                                                                                                                                                                                                                                                                                                                                                        getEvalInfo: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                          method getLocalsMap

                                                                                                                                                                                                                                                                                                                                                                                                                                          getLocalsMap: () => any;

                                                                                                                                                                                                                                                                                                                                                                                                                                            method has

                                                                                                                                                                                                                                                                                                                                                                                                                                            has: (name: string) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Template

                                                                                                                                                                                                                                                                                                                                                                                                                                              interface Template extends CommonProgram {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                property symbols

                                                                                                                                                                                                                                                                                                                                                                                                                                                symbols?: ProgramSymbols;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'Template';

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TextNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface TextNode extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property chars

                                                                                                                                                                                                                                                                                                                                                                                                                                                      chars: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type: 'TextNode';

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UndefinedLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface UndefinedLiteral extends BaseNode {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property original

                                                                                                                                                                                                                                                                                                                                                                                                                                                            original: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              property type

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'UndefinedLiteral';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                value: undefined;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EntityEncodingState

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EntityEncodingState = 'transformed' | 'raw';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Expression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Expression = SubExpression | PathExpression | Literal;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Literal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Literal =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | StringLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | BooleanLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | NumberLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | UndefinedLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | NullLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Node = Nodes[NodeType];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeType = keyof Nodes;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PossiblyDeprecatedBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type PossiblyDeprecatedBlock = Block | Template;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Statement =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MustacheStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | BlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | PartialStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MustacheCommentStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | CommentStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | TextNode
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | ElementNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TopLevelStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TopLevelStatement = Statement | Template | Block | AttrNode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Package Files (13)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dependencies (4)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Dev Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  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/@glimmer/syntax.

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