@glimmer/compiler

  • Version 0.94.10
  • Published
  • 1.17 MB
  • 4 dependencies
  • MIT license

Install

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

Overview

Overview not available.

Index

Variables

variable APPEND_EXPR_HEAD

const APPEND_EXPR_HEAD: string;

    variable APPEND_PATH_HEAD

    const APPEND_PATH_HEAD: string;

      variable ARG_VAR

      const ARG_VAR: string;

        variable BLOCK_HEAD

        const BLOCK_HEAD: string;

          variable BLOCK_VAR

          const BLOCK_VAR: string;

            variable BUILDER_APPEND

            const BUILDER_APPEND: number;

              variable BUILDER_COMMENT

              const BUILDER_COMMENT: number;

                variable BUILDER_CONCAT

                const BUILDER_CONCAT: number;

                  variable BUILDER_DYNAMIC_COMPONENT

                  const BUILDER_DYNAMIC_COMPONENT: number;

                    variable BUILDER_GET

                    const BUILDER_GET: number;

                      variable BUILDER_HAS_BLOCK

                      const BUILDER_HAS_BLOCK: number;

                        variable BUILDER_HAS_BLOCK_PARAMS

                        const BUILDER_HAS_BLOCK_PARAMS: number;

                          variable BUILDER_LITERAL

                          const BUILDER_LITERAL: number;

                            variable BUILDER_MODIFIER

                            const BUILDER_MODIFIER: number;

                              variable CALL_EXPR

                              const CALL_EXPR: string;

                                variable CALL_HEAD

                                const CALL_HEAD: string;

                                  variable COMMENT_HEAD

                                  const COMMENT_HEAD: string;

                                    variable CONCAT_EXPR

                                    const CONCAT_EXPR: string;

                                      variable defaultId

                                      const defaultId: TemplateIdFn;

                                        variable DYNAMIC_COMPONENT_HEAD

                                        const DYNAMIC_COMPONENT_HEAD: string;

                                          variable ELEMENT_HEAD

                                          const ELEMENT_HEAD: string;

                                            variable FREE_VAR

                                            const FREE_VAR: string;

                                              variable GET_PATH_EXPR

                                              const GET_PATH_EXPR: string;

                                                variable GET_VAR_EXPR

                                                const GET_VAR_EXPR: string;

                                                  variable HAS_BLOCK_EXPR

                                                  const HAS_BLOCK_EXPR: string;

                                                    variable HAS_BLOCK_PARAMS_EXPR

                                                    const HAS_BLOCK_PARAMS_EXPR: string;

                                                      variable KEYWORD_HEAD

                                                      const KEYWORD_HEAD: string;

                                                        variable LITERAL_EXPR

                                                        const LITERAL_EXPR: string;

                                                          variable LITERAL_HEAD

                                                          const LITERAL_HEAD: string;

                                                            variable LOCAL_VAR

                                                            const LOCAL_VAR: string;

                                                              variable MODIFIER_HEAD

                                                              const MODIFIER_HEAD: string;

                                                                variable NEWLINE

                                                                const NEWLINE: string;

                                                                  variable SPLAT_HEAD

                                                                  const SPLAT_HEAD: string;

                                                                    variable THIS_VAR

                                                                    const THIS_VAR: string;

                                                                      Functions

                                                                      function buildStatement

                                                                      buildStatement: (
                                                                      normalized: NormalizedStatement,
                                                                      symbols?: Symbols
                                                                      ) => WireFormat.Statement[];

                                                                        function buildStatements

                                                                        buildStatements: (
                                                                        statements: BuilderStatement[],
                                                                        symbols: Symbols
                                                                        ) => WireFormat.Statement[];

                                                                          function c

                                                                          c: (arr: TemplateStringsArray, ...interpolated: unknown[]) => BuilderComment;

                                                                            function precompile

                                                                            precompile: (
                                                                            source: string,
                                                                            options?: PrecompileOptions | PrecompileOptionsWithLexicalScope
                                                                            ) => TemplateJavascript;

                                                                              function precompileJSON

                                                                              precompileJSON: (
                                                                              string: Nullable<string>,
                                                                              options?: PrecompileOptions | PrecompileOptionsWithLexicalScope
                                                                              ) => [block: SerializedTemplateBlock, usedLocals: string[]];

                                                                                function s

                                                                                s: (
                                                                                arr: TemplateStringsArray,
                                                                                ...interpolated: unknown[]
                                                                                ) => [BUILDER_LITERAL, string];

                                                                                  function unicode

                                                                                  unicode: (charCode: string) => string;

                                                                                    Classes

                                                                                    class ProgramSymbols

                                                                                    class ProgramSymbols implements Symbols {}

                                                                                      property top

                                                                                      top: ProgramSymbols;

                                                                                        method arg

                                                                                        arg: (name: string) => number;

                                                                                          method block

                                                                                          block: (name: string) => number;

                                                                                            method child

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

                                                                                              method freeVar

                                                                                              freeVar: (name: string) => number;

                                                                                                method hasLocal

                                                                                                hasLocal: (_name: string) => false;

                                                                                                  method local

                                                                                                  local: (name: string) => never;

                                                                                                    method symbol

                                                                                                    symbol: (name: string) => number;

                                                                                                      method this

                                                                                                      this: () => number;

                                                                                                        method toSymbols

                                                                                                        toSymbols: () => string[];

                                                                                                          method toUpvars

                                                                                                          toUpvars: () => string[];

                                                                                                            class WireFormatDebugger

                                                                                                            class WireFormatDebugger {}

                                                                                                              constructor

                                                                                                              constructor([_statements, symbols, upvars]: SerializedTemplateBlock);

                                                                                                                method format

                                                                                                                format: (program: SerializedTemplateBlock) => unknown;

                                                                                                                  method formatOpcode

                                                                                                                  formatOpcode: (opcode: WireFormat.Syntax) => unknown;

                                                                                                                    Type Aliases

                                                                                                                    type BuilderStatement

                                                                                                                    type BuilderStatement =
                                                                                                                    | VerboseStatement
                                                                                                                    | SugaryArrayStatement
                                                                                                                    | TupleBuilderExpression
                                                                                                                    | string;

                                                                                                                      Package Files (1)

                                                                                                                      Dependencies (4)

                                                                                                                      Dev Dependencies (11)

                                                                                                                      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/compiler.

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